.mise.toml

@@ -1,2 +0,0 @@
-[tools]
-nim = "2.2.0"

README.md

@@ -1,138 +0,0 @@
-# Personal Issue Tracker
-
-This is [Jonathan Bernard's](mailto:jonathan@jdbernard.com) personal issue
-tracker. In it's current form it is essentially a way to keep an curated list of
-TODO's, organizing them by workflow category (todo, todo-today, dormant, etc.)
-and context (Personal, Work, etc.).
-
-## Categories
-
-`pit` organizes issues into the following workflow categories:
-
-- `current` - actively in progress
-- `todo` - to be addressed in the future
-- `todo-today` - chosen to be addressed today
-- `pending` - blocked by some third party
-- `dormant` - long-term things I don't want to forget but don't need in front
-  of me every day.
-- `done`
-
-In my typical workflow the `todo` category serves as a collection point for
-things I want to keep track of. Then on a a daily basis I review issues in the
-`todo` category and move a selection to the `todo-today` category. I also try
-to keep the total number of issues in the `todo` below about a dozen. If there
-are more than a dozen things in my `todo` category I will identify the lowest
-priority items and move them to the `dormant` category.
-
-## Issue Properties
-
-`pit` allows arbitrary properties to be attached to issues in the form of
-key-value pairs. On the command line these can be provided via the `-p` or
-`--properties` parameter in the form
-`-p <prop1Name>:<prop1Value>;<prop2Name>:<prop2Value>[;...]`
-
-There are a couple of properties that pit will recognize automatically:
-
-- `context`: the context organization feature is implemented using issue
-  properties.
-- `created`: `pit` uses this property to timestamp an issue when it is created.
-- `completed`: `pit` uses this property to timestamp an issue when it is moved
-  to the `done` category.
-- `pending`: `pit` looks to this property to provide extra information about
-  issues in the `pending` category. Typically I use this to note who or what is
-  blocking the issue and why.
-
-Some other common properties I use are:
-
-- `resolution`: for short notes about why an issue was moved to `done`,
-  especially if it the action wasn't taken or if it is not completely clear
-  that this issue was completed.
-
-## Configuration Options
-
-`pit` allows configuration via command-line options and via a configuration
-file. There is some overlap between the two methods of configuring `pit`, but
-it is not a complete mapping.
-
-### Config File
-
-`pit` looks for a JSON configuration file in the following places (in order):
-
-1. From a file path passed on the command line via the `--config <cfgFile>` parameter,
-2. `./.pitrc`, in the current working directory,
-3. From a file path set in the `PITRC` environment variable.
-4. `$HOME/.pitrc`, in the user's home directory.
-
-
-#### Sample Config File
-
-This example illustrates all of the possible configuration options.
-
-```json
-{
-  "api": {
-    "apiKeys": [
-      "50cdcb660554e2d50fd88bd40b6579717bf00643f6ff57f108baf16c8c083f77",
-      "e4fc1aac49fc1f2f7f4ca6b1f04d41a4ccdd58e13bb53b41da97703d47267ceb",
-    ]
-  },
-  "cli": {
-    "defaultContext": "personal",
-    "verbose": false,
-    "termWidth": 120,
-    "triggerPtk": true
-  },
-  "contexts": {
-    "nla-music": "New Life Music",
-    "nla-youth-band": "New Life Youth Band",
-    "acn": "Accenture",
-    "hff": "Hope Family Fellowship"
-  },
-  "tasksDir": "/mnt/c/Users/Jonathan Bernard/synced/tasks"
-}
-```
-
-#### Explanation of configurable options.
-
-In general, options supplied on the CLI directly will override options supplied
-in the configuration file. All options are optional unless stated otherwise.
-
-* `api`: configuration options specific to the API service.
-
-  - `apiKeys`: a list of Bearer tokens accepted by the API for the purpose of
-    authenticating API requests.
-
-* `cli`: configuration options specific to the CLI.
-
-  - `defaultContext`: if present all invokations to the CLI will
-    be in this context. This is like adding a `--context <defaultContext>`
-    parameter to every CLI invocation. Any actual `--context` parameter will
-    override this value.
-
-  - `verbose`: Show issue details when listing issues (same as
-    `--verbose` flag).
-
-  - `termWidth`: Set the expected width of the terminal (for wrapping text).
-
-  - `triggerPtk`: If set to `true`, invoke the `ptk` command to start and stop
-    timers when issues move to the `current` and `done` categories
-    respectively.
-
-* `contexts`: `pit` allows issues to be organized into different contexts via
-  a `context` property on the issue. The CLI groups issues according to
-  context. When printing contexts the CLI will take the value from the issues'
-  `context` properties and capatalize it. In some cases you may wish to have a
-  different display value for a context. I like to use abbreviations for long
-  context names to reduce the need to type, `hff` for "Hope Family Fellowship",
-  for example. The `contexts` config option allows you to provide a map of
-  context values to context display names See the sample file below for an
-  example.
-
-  Note that this mapping does not have to have entries for all contexts, only
-  those you wish to provide with an alternate display form. For example, in the
-  configuration sample above the default context is `personal`, a value not
-  present in the `contexts` configuration. `personal` will be displayed as
-  "Personal"; it does not need an alternate display name.
-
-* `tasksDir` **required**: a file path to the root directory for the issue
-  repository (same as `--tasks-dir` CLI parameter).

pit.nimble

@@ -1,31 +1,15 @@
 # Package
 
-version       = "4.29.1"
+include "src/pitpkg/version.nim"
+
+version       = PIT_VERSION
 author        = "Jonathan Bernard"
 description   = "Personal issue tracker."
 license       = "MIT"
 srcDir        = "src"
-installExt    = @["nim"]
+bin           = @["pit", "pit_api"]
-bin           = @["pit"]
 
 # Dependencies
 
-requires @[
+requires @[ "nim >= 0.19.0", "cliutils 0.6.1", "docopt 0.6.8", "jester 0.4.1",
-  "nim >= 1.4.0",
+  "langutils >= 0.4.0", "timeutils 0.4.0", "uuids 0.1.10" ]
-  "docopt >= 0.7.1",
-  "jester >= 0.6.0",
-  "uuids >= 0.1.10",
-  "zero_functional"
-]
-
-# Dependencies from git.jdb-software.com/jdb/nim-packages
-requires @[
-  "cliutils >= 0.9.1",
-  "langutils >= 0.4.0",
-  "timeutils >= 0.5.4",
-  "data_uri > 1.0.0",
-  "update_nim_package_version >= 0.2.0"
-]
-
-task updateVersion, "Update the version of this package.":
-  exec "update_nim_package_version pit 'src/pit/cliconstants.nim'"

src/config.nims

@@ -1 +0,0 @@
-switch("define", "ssl")

src/pit.nim

@@ -1,19 +1,159 @@
 ## Personal Issue Tracker CLI interface
 ## ====================================
 
-import std/[algorithm, logging, options, os, sequtils, tables, times, unicode]
+import cliutils, docopt, json, logging, options, os, ospaths, sequtils,
-import data_uri, docopt, json, timeutils, uuids
+  tables, terminal, times, timeutils, unicode, uuids
 
 from nre import re
-import strutils except alignLeft, capitalize, strip, toUpper, toLower
+import strutils except capitalize, strip, toUpper, toLower
-import pit/[cliconstants, formatting, libpit, sync_pbm_vsb]
+import pitpkg/private/libpit
+export libpit
 
-export formatting, libpit
+include "pitpkg/version.nim"
+
+type
+  CliContext = ref object
+    cfg*: PitConfig
+    contexts*: TableRef[string, string]
+    defaultContext*: Option[string]
+    tasksDir*: string
+    issues*: TableRef[IssueState, seq[Issue]]
+    termWidth*: int
+    triggerPtk*, verbose*: bool
 
 let EDITOR =
   if existsEnv("EDITOR"): getEnv("EDITOR")
   else: "vi"
 
+
+proc initContext(args: Table[string, Value]): CliContext =
+  let pitCfg = loadConfig(args)
+
+  let cliJson =
+    if pitCfg.cfg.json.hasKey("cli"): pitCfg.cfg.json["cli"]
+    else: newJObject()
+
+  let cliCfg = CombinedConfig(docopt: args, json: cliJson)
+
+  result = CliContext(
+    contexts: pitCfg.contexts,
+    defaultContext:
+      if not cliJson.hasKey("defaultContext"): none(string)
+      else: some(cliJson["defaultContext"].getStr()),
+    verbose: parseBool(cliCfg.getVal("verbose", "false")) and not args["--quiet"],
+    issues: newTable[IssueState, seq[Issue]](),
+    tasksDir: pitCfg.tasksDir,
+    termWidth: parseInt(cliCfg.getVal("term-width", "80")),
+    triggerPtk: cliJson.getOrDefault("triggerPtk").getBool(false))
+
+proc getIssueContextDisplayName(ctx: CliContext, context: string): string =
+  if not ctx.contexts.hasKey(context):
+    if context.isNilOrWhitespace: return "<default>"
+    else: return context.capitalize()
+  return ctx.contexts[context]
+
+proc formatIssue(ctx: CliContext, issue: Issue): string =
+  result = ($issue.id).withColor(fgBlack, true) & "\n"&
+           issue.summary.withColor(fgWhite) & "\n"
+
+  if issue.tags.len > 0:
+    result &= "tags: ".withColor(fgMagenta) &
+              issue.tags.join(",").withColor(fgGreen, true) & "\n"
+
+  if issue.properties.len > 0:
+    result &= termColor(fgMagenta)
+    for k, v in issue.properties: result &= k & ": " & v & "\n"
+
+
+  result &= "--------".withColor(fgBlack, true) & "\n"
+  if not issue.details.isNilOrWhitespace:
+    result &= issue.details.strip.withColor(fgCyan) & "\n"
+
+proc formatSectionIssue(ctx: CliContext, issue: Issue, width: int, indent = "",
+                verbose = false): string =
+
+  result = ""
+
+  var showDetails = not issue.details.isNilOrWhitespace and verbose
+
+  var prefixLen = 0
+  var summaryIndentLen = indent.len + 7
+
+  if issue.hasProp("delegated-to"): prefixLen += issue["delegated-to"].len + 2 # space for the ':' and ' '
+
+  # Wrap and write the summary.
+  var wrappedSummary = ("+".repeat(prefixLen) & issue.summary).wordWrap(width - summaryIndentLen).indent(summaryIndentLen)
+
+  wrappedSummary = wrappedSummary[(prefixLen + summaryIndentLen)..^1]
+
+  result = (indent & ($issue.id)[0..<6]).withColor(fgBlack, true) & " "
+
+  if issue.hasProp("delegated-to"):
+    result &= (issue["delegated-to"] & ": ").withColor(fgGreen)
+
+  result &= wrappedSummary.withColor(fgWhite)
+
+  if issue.tags.len > 0:
+    let tagsStr = "(" & issue.tags.join(", ") & ")"
+    if (result.splitLines[^1].len + tagsStr.len + 1) > (width - 2):
+      result &= "\n" & indent
+    result &= " " & tagsStr.withColor(fgGreen)
+
+
+  if issue.hasProp("pending"):
+    let startIdx = "Pending: ".len
+    var pendingText = issue["pending"].wordWrap(width - startIdx - summaryIndentLen)
+                                      .indent(startIdx)
+    pendingText = ("Pending: " & pendingText[startIdx..^1]).indent(summaryIndentLen)
+    result &= "\n" & pendingText.withColor(fgCyan)
+
+  if showDetails:
+    result &= "\n" & issue.details.strip.indent(indent.len + 2).withColor(fgCyan)
+
+  result &= termReset
+
+proc formatSectionIssueList(ctx: CliContext, issues: seq[Issue], width: int,
+        indent: string, verbose: bool): string =
+
+  result = ""
+  for i in issues:
+    var issueText = ctx.formatSectionIssue(i, width, indent, verbose)
+    result &= issueText & "\n"
+
+proc formatSection(ctx: CliContext, issues: seq[Issue], state: IssueState,
+                   indent = "", verbose = false): string =
+  let innerWidth = ctx.termWidth - (indent.len * 2)
+
+  result = termColor(fgBlue) &
+    (indent & ".".repeat(innerWidth)) & "\n" &
+    state.displayName.center(ctx.termWidth) & "\n\n" &
+    termReset
+
+  let issuesByContext = issues.groupBy("context")
+
+  if issues.len > 5 and issuesByContext.len > 1:
+    for context, ctxIssues in issuesByContext:
+
+      result &= termColor(fgYellow) &
+        indent & ctx.getIssueContextDisplayName(context) & ":" &
+        termReset & "\n\n"
+
+      result &= ctx.formatSectionIssueList(ctxIssues, innerWidth - 2, indent & "  ", verbose)
+      result &= "\n"
+
+  else: result &= ctx.formatSectionIssueList(issues, innerWidth, indent, verbose)
+
+proc loadIssues(ctx: CliContext, state: IssueState) =
+  ctx.issues[state] = loadIssues(ctx.tasksDir / $state)
+
+proc loadAllIssues(ctx: CliContext) =
+  ctx.issues = newTable[IssueState, seq[Issue]]()
+  for state in IssueState: ctx.loadIssues(state)
+
+proc filterIssues(ctx: CliContext, filter: IssueFilter) =
+  for state, issueList in ctx.issues:
+    ctx.issues[state] = issueList.filter(filter)
+
 proc parsePropertiesOption(propsOpt: string): TableRef[string, string] =
   result = newTable[string, string]()
   for propText in propsOpt.split(";"):
@@ -21,21 +161,21 @@ proc parsePropertiesOption(propsOpt: string): TableRef[string, string] =
     if pair.len == 1: result[pair[0]] = "true"
     else: result[pair[0]] = pair[1]
 
-proc parseExclPropertiesOption(propsOpt: string): TableRef[string, seq[string]] =
+proc sameDay(a, b: DateTime): bool =
-  result = newTable[string, seq[string]]()
+  result = a.year == b.year and a.yearday == b.yearday
-  for propText in propsOpt.split(";"):
+
-    let pair = propText.split(":", 1)
+proc writeHeader(ctx: CliContext, header: string) =
-    let val =
+  stdout.setForegroundColor(fgRed, true)
-      if pair.len == 1: "true"
+  stdout.writeLine('_'.repeat(ctx.termWidth))
-      else: pair[1]
+  stdout.writeLine(header.center(ctx.termWidth))
-    if result.hasKey(pair[0]): result[pair[0]].add(val)
+  stdout.writeLine('~'.repeat(ctx.termWidth))
-    else: result[pair[0]] = @[val]
+  stdout.resetAttributes
 
 proc reorder(ctx: CliContext, state: IssueState) =
 
   # load the issues to make sure the order file contains all issues in the state.
   ctx.loadIssues(state)
-  discard os.execShellCmd(EDITOR & " '" & (ctx.cfg.tasksDir / $state / "order.txt") & "' </dev/tty >/dev/tty")
+  discard os.execShellCmd(EDITOR & " '" & (ctx.tasksDir / $state / "order.txt") & "' </dev/tty >/dev/tty")
 
 proc edit(issue: Issue) =
 
@@ -48,44 +188,122 @@ proc edit(issue: Issue) =
     # Try to parse the newly-edited issue to make sure it was successful.
     let editedIssue = loadIssue(issue.filepath)
     editedIssue.store()
-  except CatchableError:
+  except:
-    fatal "updated issue is invalid (ignoring edits): \n\t" &
+    fatal "pit: updated issue is invalid (ignoring edits): \n\t" &
       getCurrentExceptionMsg()
     issue.store()
 
-when isMainModule:
+proc list(ctx: CliContext, filter: Option[IssueFilter], state: Option[IssueState], showToday, showFuture, verbose: bool) =
- try:
 
-  let consoleLogger = newConsoleLogger(
+  if state.isSome:
-    levelThreshold=lvlInfo,
+    ctx.loadIssues(state.get)
-    fmtStr="pit - $levelname: ")
+    if filter.isSome: ctx.filterIssues(filter.get)
-  logging.addHandler(consoleLogger)
+    stdout.write ctx.formatSection(ctx.issues[state.get], state.get, "", verbose)
+    return
+
+  ctx.loadAllIssues()
+  if filter.isSome: ctx.filterIssues(filter.get)
+
+  let today = showToday and [Current, TodoToday].anyIt(
+    ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
+
+  let future = showFuture and [Pending, Todo].anyIt(
+    ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
+
+  let indent = if today and future: "  " else: ""
+
+  # Today's items
+  if today:
+    if future: ctx.writeHeader("Today")
+
+    for s in [Current, TodoToday]:
+      if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
+        stdout.write ctx.formatSection(ctx.issues[s], s, indent, verbose)
+
+    if ctx.issues.hasKey(Done):
+        let doneIssues = ctx.issues[Done].filterIt(
+          it.hasProp("completed") and
+          sameDay(getTime().local, it.getDateTime("completed")))
+        if doneIssues.len > 0:
+          stdout.write ctx.formatSection(doneIssues, Done, indent, verbose)
+
+  # Future items
+  if future:
+    if today: ctx.writeHeader("Future")
+
+    for s in [Pending, Todo]:
+      if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
+        stdout.write ctx.formatSection(ctx.issues[s], s, indent, verbose)
+
+when isMainModule:
+
+ try:
+  let doc = """
+Usage:
+  pit ( new | add) <summary> [<state>] [options]
+  pit list [<listable>] [options]
+  pit ( start | done | pending | todo-today | todo | suspend ) <id>... [options]
+  pit edit <ref>...
+  pit tag <id>... [options]
+  pit untag <id>... [options]
+  pit reorder <state>
+  pit delegate <id> <delegated-to>
+  pit ( delete | rm ) <id>...
+
+Options:
+
+  -h, --help                Print this usage information.
+
+  -p, --properties <props>  Specify properties. Formatted as "key:val;key:val"
+                            When used with the list command this option applies
+                            a filter to the issues listed, only allowing those
+                            which have all of the given properties.
+
+  -c, --context <ctxName>   Shorthand for '-p context:<ctxName>'
+
+  -g, --tags <tags>         Specify tags for an issue.
+
+  -T, --today               Limit to today's issues.
+
+  -F, --future              Limit to future issues.
+
+  -m, --match <pattern>     Limit to issues whose summaries match the given
+                            pattern (PCRE regex supported).
+
+  -M, --match-all <pat>     Limit to the issues whose summaries or details
+                            match the given pattern (PCRE regex supported).
+
+  -v, --verbose             Show issue details when listing issues.
+
+  -q, --quiet               Suppress verbose output.
+
+  -y, --yes                 Automatically answer "yes" to any prompts.
+
+  -C, --config <cfgFile>    Location of the config file (defaults to $HOME/.pitrc)
+
+  -E, --echo-args           Echo arguments (for debug purposes).
+
+  -d, --tasks-dir           Path to the tasks directory (defaults to the value
+                            configured in the .pitrc file)
+
+  --term-width <width>      Manually set the terminal width to use.
+"""
+
+  logging.addHandler(newConsoleLogger())
 
   # Parse arguments
-  let args = docopt(USAGE, version = PIT_VERSION)
+  let args = docopt(doc, version = PIT_VERSION)
-
-  if args["--debug"]:
-    consoleLogger.levelThreshold = lvlDebug
-
-  if args["--silent"]:
-    consoleLogger.levelThreshold = lvlNone
 
   if args["--echo-args"]: stderr.writeLine($args)
 
-  if args["help"]:
+  if args["--help"]:
-    stderr.writeLine(USAGE & "\p")
+    stderr.writeLine(doc)
-    stderr.writeLine(ONLINE_HELP)
     quit()
 
   let ctx = initContext(args)
 
-  trace "context initiated"
-
-  var updatedIssues = newSeq[Issue]()
   var propertiesOption = none(TableRef[string,string])
-  var exclPropsOption = none(TableRef[string,seq[string]])
   var tagsOption = none(seq[string])
-  var exclTagsOption = none(seq[string])
 
   if args["--properties"] or args["--context"]:
 
@@ -97,25 +315,8 @@ when isMainModule:
 
     propertiesOption = some(props)
 
-  if args["--excl-properties"] or args["--excl-context"]:
-
-    var exclProps =
-      if args["--excl-properties"]:
-        parseExclPropertiesOption($args["--excl-properties"])
-      else: newTable[string,seq[string]]()
-
-    if args["--excl-context"]:
-      if not exclProps.hasKey("context"): exclProps["context"] = @[]
-      let exclContexts = split($args["--excl-context"], ",")
-      exclProps["context"] = exclProps["context"].concat(exclContexts)
-
-    exclPropsOption = some(exclProps)
-
   if args["--tags"]: tagsOption = some(($args["--tags"]).split(",").mapIt(it.strip))
 
-  if args["--excl-tags"]: exclTagsOption =
-    some(($args["--excl-tags"]).split(",").mapIt(it.strip))
-
   ## Actual command runners
   if args["new"] or args["add"]:
     let state =
@@ -133,12 +334,12 @@ when isMainModule:
       summary: $args["<summary>"],
       properties: issueProps,
       tags:
-        if tagsOption.isSome: tagsOption.get
+        if args["--tags"]: ($args["--tags"]).split(",").mapIt(it.strip)
         else: newSeq[string]())
 
-    ctx.cfg.tasksDir.store(issue, state)
+    ctx.tasksDir.store(issue, state)
-    updatedIssues.add(issue)
+
-    stdout.writeLine formatIssue(issue)
+    stdout.writeLine ctx.formatIssue(issue)
 
   elif args["reorder"]:
     ctx.reorder(parseEnum[IssueState]($args["<state>"]))
@@ -146,58 +347,40 @@ when isMainModule:
   elif args["edit"]:
     for editRef in @(args["<ref>"]):
 
-      let propsOption =
-        if args["--properties"]:
-          some(parsePropertiesOption($args["--properties"]))
-        else: none(TableRef[string, string])
-
       var stateOption = none(IssueState)
 
       try: stateOption = some(parseEnum[IssueState](editRef))
-      except CatchableError: discard
+      except: discard
 
       if stateOption.isSome:
         let state = stateOption.get
         ctx.loadIssues(state)
-        for issue in ctx.issues[state]:
+        for issue in ctx.issues[state]: edit(issue)
-          if propsOption.isSome:
-            for k,v in propsOption.get:
-              issue[k] = v
-          edit(issue)
-          updatedIssues.add(issue)
 
-      else:
+      else: edit(ctx.tasksDir.loadIssueById(editRef))
-        let issue = ctx.cfg.tasksDir.loadIssueById(editRef)
-        if propertiesOption.isSome:
-          for k,v in propertiesOption.get:
-            issue[k] = v
-        edit(issue)
-        updatedIssues.add(issue)
 
   elif args["tag"]:
-    if tagsOption.isNone: raise newException(Exception, "no tags given")
+    if not args["--tags"]: raise newException(Exception, "no tags given")
 
-    let newTags = tagsOption.get
+    let newTags = ($args["--tags"]).split(",").mapIt(it.strip)
 
     for id in @(args["<id>"]):
-      var issue = ctx.cfg.tasksDir.loadIssueById(id)
+      var issue = ctx.tasksDir.loadIssueById(id)
       issue.tags = deduplicate(issue.tags & newTags)
       issue.store()
-      updatedIssues.add(issue)
 
   elif args["untag"]:
     let tagsToRemove: seq[string] =
-      if tagsOption.isSome: tagsOption.get
+      if args["--tags"]: ($args["--tags"]).split(",").mapIt(it.strip)
       else: @[]
 
     for id in @(args["<id>"]):
-      var issue = ctx.cfg.tasksDir.loadIssueById(id)
+      var issue = ctx.tasksDir.loadIssueById(id)
       if tagsToRemove.len > 0:
         issue.tags = issue.tags.filter(
           proc (tag: string): bool = not tagsToRemove.anyIt(it == tag))
       else: issue.tags = @[]
       issue.store()
-      updatedIssues.add(issue)
 
   elif args["start"] or args["todo-today"] or args["done"] or
        args["pending"] or args["todo"] or args["suspend"]:
@@ -211,60 +394,34 @@ when isMainModule:
     elif args["suspend"]: targetState = Dormant
 
     for id in @(args["<id>"]):
-      var issue = ctx.cfg.tasksDir.loadIssueById(id)
+      var issue = ctx.tasksDir.loadIssueById(id)
       if propertiesOption.isSome:
         for k,v in propertiesOption.get:
           issue[k] = v
-      if targetState == Done:
+      if targetState == Done: issue["completed"] = getTime().local.formatIso8601
-        issue["completed"] = getTime().local.formatIso8601
+      issue.changeState(ctx.tasksDir, targetState)
-        if issue.hasProp("recurrence") and issue.getRecurrence.isSome:
-          let nextIssue = ctx.cfg.tasksDir.nextRecurrence(issue.getRecurrence.get, issue)
-          ctx.cfg.tasksDir.store(nextIssue, TodoToday)
-          info "created the next recurrence:"
-          updatedIssues.add(nextIssue)
-          stdout.writeLine formatIssue(nextIssue)
 
-
+    if ctx.triggerPtk:
-      issue.changeState(ctx.cfg.tasksDir, targetState)
-      updatedIssues.add(issue)
-
-    if ctx.triggerPtk or args["--ptk"]:
       if targetState == Current:
-        let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"][0]))
+        let issue = ctx.tasksDir.loadIssueById($(args["<id>"][0]))
-        var cmd = "ptk start"
+        var cmd = "ptk start "
-        if issue.tags.len > 0 or issue.hasProp("context"):
+        if issue.tags.len > 0: cmd &= "-g \"" & issue.tags.join(",") & "\""
-          let tags = concat(
+        cmd &= " \"" & issue.summary & "\""
-            issue.tags,
-            if issue.hasProp("context"): @[issue.properties["context"]]
-            else: @[]
-          )
-          cmd &= " -g \"" & tags.join(",") & "\""
-        cmd &= " -n \"pit-id: " & $issue.id & "\""
-        cmd &= " \"[" & ($issue.id)[0..<6] & "] " & issue.summary & "\""
         discard execShellCmd(cmd)
       elif targetState == Done or targetState == Pending:
         discard execShellCmd("ptk stop")
 
-  elif args["hide-until"]:
-
-    let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
-    issue.setDateTime("hide-until", parseDate($args["<date>"]))
-
-    issue.store()
-    updatedIssues.add(issue)
-
   elif args["delegate"]:
 
-    let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
+    let issue = ctx.tasksDir.loadIssueById($(args["<id>"]))
     issue["delegated-to"] = $args["<delegated-to>"]
 
     issue.store()
-    updatedIssues.add(issue)
 
   elif args["delete"] or args["rm"]:
     for id in @(args["<id>"]):
 
-      let issue = ctx.cfg.tasksDir.loadIssueById(id)
+      let issue = ctx.tasksDir.loadIssueById(id)
 
       if not args["--yes"]:
         stderr.write("Delete '" & issue.summary & "' (y/n)? ")
@@ -272,7 +429,6 @@ when isMainModule:
           continue
 
       issue.delete
-      updatedIssues.add(issue)
 
   elif args["list"]:
 
@@ -284,11 +440,6 @@ when isMainModule:
       filter.properties = propertiesOption.get
       filterOption = some(filter)
 
-    # Add property exclusions (if given)
-    if exclPropsOption.isSome:
-      filter.exclProperties = exclPropsOption.get
-      filterOption = some(filter)
-
     # If they supplied text matches, add that to the filter.
     if args["--match"]:
       filter.summaryMatch = some(re("(?i)" & $args["--match"]))
@@ -304,35 +455,21 @@ when isMainModule:
       filter.properties["context"] = ctx.defaultContext.get
       filterOption = some(filter)
 
-    if tagsOption.isSome:
-      filter.hasTags = tagsOption.get
-      filterOption = some(filter)
-
-    if exclTagsOption.isSome:
-      filter.exclTags = exclTagsOption.get
-      filterOption = some(filter)
-
     # Finally, if the "context" is "all", don't filter on context
     if filter.properties.hasKey("context") and
        filter.properties["context"] == "all":
 
       filter.properties.del("context")
-      filter.exclProperties.del("context")
 
     var listContexts = false
-    var listTags = false
+    var stateOption = none(IssueState)
-    var statesOption = none(seq[IssueState])
+    var issueIdOption = none(string)
-    var issueIdsOption = none(seq[string])
 
-    if args["contexts"]: listContexts = true
+    if args["<listable>"]:
-    elif args["tags"]: listTags = true
+      if $args["<listable>"] == "contexts": listContexts = true
-    elif args["<stateOrId>"]:
+      else:
-      try:
+        try: stateOption = some(parseEnum[IssueState]($args["<listable>"]))
-        statesOption =
+        except: issueIdOption = some($args["<listable>"])
-          some(args["<stateOrId>"].
-          mapIt(parseEnum[IssueState]($it)))
-      except CatchableError:
-        issueIdsOption = some(args["<stateOrId>"].mapIt($it))
 
     # List the known contexts
     if listContexts:
@@ -343,110 +480,21 @@ when isMainModule:
           if issue.hasProp("context") and not uniqContexts.contains(issue["context"]):
             uniqContexts.add(issue["context"])
 
-      let maxLen = foldl(uniqContexts,
+      for c in uniqContexts: stdout.writeLine(c)
-        if a.len > b.len: a
-        else: b
-      ).len
-
-      for c in uniqContexts.sorted:
-        stdout.writeLine(c.alignLeft(maxLen+2) & ctx.getIssueContextDisplayName(c))
-
-    elif listTags:
-      var uniqTags = newseq[string]()
-      if statesOption.isSome:
-        for state in statesOption.get: ctx.loadIssues(state)
-      else: ctx.loadAllIssues()
-
-      if filterOption.isSome: ctx.filterIssues(filterOption.get)
-
-      for state, issueList in ctx.issues:
-        for issue in issueList:
-          for tag in issue.tags:
-            if not uniqTags.contains(tag): uniqTags.add(tag)
-
-      stdout.writeLine(uniqTags.sorted.join("\n"))
 
     # List a specific issue
-    elif issueIdsOption.isSome:
+    elif issueIdOption.isSome:
-      for issueId in issueIdsOption.get:
+      let issue = ctx.tasksDir.loadIssueById(issueIdOption.get)
-        let issue = ctx.cfg.tasksDir.loadIssueById(issueId)
+      stdout.writeLine ctx.formatIssue(issue)
-        stdout.writeLine formatIssue(issue)
 
     # List all issues
     else:
-      trace "listing all issues"
       let showBoth = args["--today"] == args["--future"]
-      ctx.list(
+      ctx.list(filterOption, stateOption, showBoth or args["--today"],
-        filter = filterOption,
+                                          showBoth or args["--future"],
-        states = statesOption,
+                                          ctx.verbose)
-        showToday = showBoth or args["--today"],
-        showFuture = showBoth or args["--future"],
-        showHidden = args["--show-hidden"],
-        verbose = ctx.verbose)
 
-  elif args["add-binary-property"]:
+ except:
-    let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
+  fatal "pit: " & getCurrentExceptionMsg()
-
-    let propIn =
-      if $(args["<propSource>"]) == "-": stdin
-      else: open($(args["<propSource>"]))
-
-    try: issue[$(args["<propName>"])] = encodeAsDataUri(readAll(propIn))
-    finally: close(propIn)
-
-    issue.store()
-    updatedIssues.add(issue)
-
-  elif args["get-binary-property"]:
-    let issue = ctx.cfg.tasksDir.loadIssueById($(args["<id>"]))
-
-    if not issue.hasProp($(args["<propName>"])):
-      raise newException(Exception,
-        "issue " & ($issue.id)[0..<6] & " has no property name '" &
-        $(args["<propName>"]) & "'")
-
-    let propOut =
-      if $(args["<propDest>"]) == "-": stdout
-      else: open($(args["<propDest>"]), fmWrite)
-
-    try: write(propOut, decodeDataUri(issue[$(args["<propName>"])]))
-    finally: close(propOut)
-
-  elif args["show-dupes"]:
-    ctx.loadAllIssues()
-
-    var idsToPaths = newTable[string, var seq[string]]()
-    for (state, issues) in pairs(ctx.issues):
-      for issue in issues:
-        let issueId = $issue.id
-
-        if idsToPaths.hasKey(issueId): idsToPaths[issueId].add(issue.filepath)
-        else: idsToPaths[issueId] = @[issue.filepath]
-
-    for (issueId, issuePaths) in pairs(idsToPaths):
-      if issuePaths.len < 2: continue
-      stdout.writeLine(issueId & ":\p  " & issuePaths.join("\p  ") & "\p\p")
-
-  elif args["sync"]:
-    if ctx.cfg.syncTargets.len == 0:
-      info "No sync targets configured"
-
-    for syncTarget in ctx.cfg.syncTargets:
-      let syncCtx = initSyncContext(ctx.cfg, syncTarget)
-
-      sync(syncCtx, args["--dry-run"])
-
-  # after doing stuff, sync if auto-sync is requested
-  if ctx.cfg.autoSync:
-    for syncTarget in ctx.cfg.syncTargets:
-      let syncCtx = initSyncContext(ctx.cfg, syncTarget)
-      if anyIt(
-          updatedIssues,
-          it.hasProp("context") and it["context"] == syncCtx.issueContext):
-        sync(syncCtx, false)
-
- except CatchableError:
-  fatal getCurrentExceptionMsg()
-  debug getCurrentException().getStackTrace()
   #raise getCurrentException()
   quit(QuitFailure)

src/pit/cliconstants.nim

@@ -1,194 +0,0 @@
-const PIT_VERSION* = "4.29.1"
-
-const USAGE* = """Usage:
-  pit ( new | add) <summary> [<state>] [options]
-  pit list contexts [options]
-  pit list tags [options]
-  pit list [<stateOrId>...] [options]
-  pit ( start | done | pending | todo-today | todo | suspend ) <id>... [options]
-  pit edit <ref>... [options]
-  pit tag <id>... [options]
-  pit untag <id>... [options]
-  pit reorder <state> [options]
-  pit delegate <id> <delegated-to> [options]
-  pit hide-until <id> <date> [options]
-  pit ( delete | rm ) <id>... [options]
-  pit add-binary-property <id> <propName> <propSource> [options]
-  pit get-binary-property <id> <propName> <propDest> [options]
-  pit show-dupes
-  pit sync [<syncTarget>...] [options]
-  pit help [options]
-
-Options:
-
-  -h, --help                Print this usage and help information.
-
-  -p, --properties <props>  Specify properties. Formatted as "key:val;key:val"
-                            When used with the list command this option applies
-                            a filter to the issues listed, only allowing those
-                            which have all of the given properties.
-
-  -P, --excl-properties <props>
-                            When used with the list command, exclude issues
-                            that contain properties with the given value. This
-                            parameter is formatted the same as the --properties
-                            parameter: "key:val;key:val"
-
-  -c, --context <ctx>       Shorthand for '-p context:<ctx>'
-
-  -C, --excl-context <ctx>  Don't show issues from the given context(s).
-                            Multiple contexts can be excluded using a ',' to
-                            separate names. For example: -C ctx1,ctx2
-                            Shorthand for '-P context:<ctx>'
-
-  -g, --tags <tags>         Specify tags for an issue. Tags are specified as a
-                            comma-delimited list. For example: -g tag1,tag2
-
-  -G, --excl-tags <tags>    When used with the list command, exclude issues
-                            that contain any of the provided tags. Tags are
-                            specified as a comma-delimited list.
-                            For example: -G tag1,tag2
-
-  -T, --today               Limit to today's issues.
-
-  -F, --future              Limit to future issues.
-
-  -H, --show-hidden         Show all matching issues, ignoring any 'hide-until'
-                            properties set.
-
-  -m, --match <pattern>     Limit to issues whose summaries match the given
-                            pattern (PCRE regex supported).
-
-  -M, --match-all <pat>     Limit to the issues whose summaries or details
-                            match the given pattern (PCRE regex supported).
-
-  -v, --verbose             Show issue details when listing issues.
-
-  -q, --quiet               Suppress verbose output.
-
-  -y, --yes                 Automatically answer "yes" to any prompts.
-
-  --config <cfgFile>        Location of the config file (defaults to $HOME/.pitrc)
-
-  -E, --echo-args           Echo arguments (for debug purposes).
-
-  -d, --tasks-dir           Path to the tasks directory (defaults to the value
-                            configured in the .pitrc file)
-
-  --ptk                     Enable PTK integration for this command.
-
-  --debug                   Enable debug-level log output.
-
-  --dry-run                 Currently only supported by the `sync` command:
-                            only print the changes that would be made, but do
-                            not actually make them.
-
-  -s, --silent              Suppress all logging and status output.
-"""
-
-const ONLINE_HELP* = """Issue States:
-
-  PIT organizes issues around their state, which is one of:
-
-    current     - issues actively being worked
-    todo-today  - issues planned for today
-    pending     - issues that are blocked by some third-party
-    done        - issues that have been completely resolved
-    todo        - issues that need to be done in the future
-    dormant     - issues that are low-priority, to be tracked, but hidden
-                  by default
-
-Issue Properties:
-
-  PIT supports adding arbitrary properties to any issue to track any metadata
-  about the issue the user may wish. There are several properties that have
-  special behavior attached to them. They are:
-
-    created
-
-      If present, expected to be an ISO 8601-formatted date that represents the
-      time when the issue was created. E.g.:
-
-          created: 2023-07-13T13:28:41-05:00
-
-    completed
-
-      If present, expected to be an ISO 8601-formatted date that represents the
-      time when the issue moved to the "done" state.  PIT will add this
-      property automatically when you use the "done" command, and can filter on
-      this value.
-
-          completed: 2023-04-27T11:52:28-05:00
-
-    context
-
-      Allows issues to be organized into contexts. The -c option is short-hand
-      for '-p context:<context-name>' and the 'list contexts' command will show
-      all values of 'context' set in existing issues.
-
-          context: family
-
-    delegated-to
-
-      When an issue now belongs to someone else, but needs to be monitored for
-      completion, this allows you to keep the issue in its current state but
-      note how it has been delegated. When present PIT will prepend this value
-      to the issue summary with an accent color.
-
-          delegated-to: Bob Ross
-
-    hide-until
-
-      When present, expected to be an ISO 8601-formatted date and used to
-      supress the display of the issue until on or after the given date.
-
-          hide-until: 2024-01-01T13:45:00-05:00
-
-    pending
-
-      When an issue is blocked by a third party, this property can be used to
-      capture details about the dependency When present PIT will display this
-      value after the issue summary.
-
-          pending: Results of WCAG analysis.
-
-    recurrence
-
-      When an issue is moved to the "done" state, if the issue has a valid
-      "recurrence" property, PIT will create a new issue and set the
-      "hide-until" property for that new issue depending on the recurrence
-      definition.
-
-      A valid recurrence value has a time value and optionally has an source
-      issue ID. For example:
-
-          recurrence: every 5 days, 10a544
-
-      The first word, "every", is expected to be either "every" or "after".
-
-      The second portion is expected to be a time period. Supported time units
-      are "hour", "day", "week", "month", an "year", along with the plural
-      forms (e.g. "5 days", "8 hours", etc.).
-
-      The final portion is the source issue ID. This is optional. When a source
-      issue ID is given, the new issue is created as a clone of the given
-      issue. When not given, the issue being closed is used for cloning.
-
-      The "every" and "after" keywords allow the user to choose whether the new
-      issue is created based on the creation time ("every") or the completion
-      time ("after") of the issue being closed based.
-
-      Examples:
-
-          every day
-          every 2 days
-          after 2 days
-          every week
-          after 12 hours
-          every 2 weeks, 10a544
-
-    tags
-
-      If present, expected to be a comma-delimited list of text tags. The -g
-      option is a short-hand for '-p tags:<tags-value>'.
-"""

src/pit/formatting.nim

@@ -1,251 +0,0 @@
-import std/[options, sequtils, wordwrap, tables, terminal, times, unicode, wordwrap]
-import cliutils, uuids
-import std/strutils except alignLeft, capitalize, strip, toLower, toUpper
-import ./libpit
-
-proc adjustedTerminalWidth(): int = min(terminalWidth(), 80)
-
-proc getIssueContextDisplayName*(ctx: CliContext, context: string): string =
-  if not ctx.contexts.hasKey(context):
-    if context.isEmptyOrWhitespace: return "<default>"
-    else: return context.capitalize()
-  return ctx.contexts[context]
-
-
-proc formatIssue*(issue: Issue): string =
-  result = ($issue.id).withColor(fgBlack, true) & "\n"&
-           issue.summary.withColor(fgWhite) & "\n"
-
-  if issue.tags.len > 0:
-    result &= "tags: ".withColor(fgMagenta) &
-              issue.tags.join(",").withColor(fgGreen, true) & "\n"
-
-  if issue.properties.len > 0:
-    result &= termColor(fgMagenta)
-    for k, v in issue.properties: result &= k & ": " & v & "\n"
-
-
-  result &= "--------".withColor(fgBlack, true) & "\n"
-  if not issue.details.isEmptyOrWhitespace:
-    result &= issue.details.strip.withColor(fgCyan) & "\n"
-
-  result &= termReset
-
-
-proc formatPlainIssueSummary*(issue: Issue): string =
-
-  result = "$#: $# $#" % [
-    $issue.state,
-    ($issue.id)[0..<6],
-    issue.summary ]
-
-  if issue.hasProp("delegated-to") or issue.hasProp("pending"):
-    var parts = newSeq[string]()
-
-    if issue.hasProp("delegated-to"):
-      parts.add("delegated to " & issue["delegated-to"])
-
-    if issue.hasProp("pending"):
-      parts.add("pendin: " & issue["pending"])
-
-    result &= "($#)" % [ parts.join("; ") ]
-
-
-proc formatSectionIssue*(
-    issue: Issue,
-    width: int = 80,
-    indent = "",
-    verbose = false): string =
-
-  result = (indent & ($issue.id)[0..<6]).withColor(fgBlack, true) & " "
-
-  let showDetails = not issue.details.isEmptyOrWhitespace and verbose
-
-  let summaryIndentLen = indent.len + 7
-  let summaryWidth = width - summaryIndentLen
-
-  let summaryLines = issue.summary
-    .wrapWords(summaryWidth)
-    .splitLines
-
-  result &= summaryLines[0].withColor(fgWhite)
-
-  for line in summaryLines[1..^1]:
-    result &= "\p" & line.indent(summaryIndentLen)
-
-  var lastLineLen = summaryLines[^1].len
-
-  if issue.hasProp("delegated-to"):
-    if lastLineLen + issue["delegated-to"].len + 1 < summaryWidth:
-      result &= " " & issue["delegated-to"].withColor(fgMagenta)
-      lastLineLen += issue["delegated-to"].len + 1
-    else:
-      result &= "\p" & issue["delegated-to"]
-        .withColor(fgMagenta)
-        .indent(summaryIndentLen)
-      lastLineLen = issue["delegated-to"].len
-
-  if issue.tags.len > 0:
-    let tagsStrLines = ("(" & issue.tags.join(", ") & ")")
-      .wrapWords(summaryWidth)
-      .splitLines
-
-    if tagsStrLines.len == 1 and
-       (lastLineLen + tagsStrLines[0].len + 1) < summaryWidth:
-      result &= " " & tagsStrLines[0].withColor(fgGreen)
-      lastLineLen += tagsStrLines[0].len + 1
-    else:
-      result &= "\p" & tagsStrLines
-        .mapIt(it.indent(summaryIndentLen))
-        .join("\p")
-        .withColor(fgGreen)
-      lastLineLen = tagsStrLines[^1].len
-
-  if issue.hasProp("pending"):
-    result &= "\p" & ("Pending: " & issue["pending"])
-      .wrapwords(summaryWidth)
-      .withColor(fgCyan)
-      .indent(summaryIndentLen)
-
-  if showDetails:
-    result &= "\p" & issue.details
-      .strip
-      .withColor(fgBlack, bright = true)
-      .indent(summaryIndentLen)
-
-  result &= termReset
-
-
-proc formatSectionIssueList*(
-    issues: seq[Issue],
-    width: int = 80,
-    indent: string = "",
-    verbose: bool = false): string =
-
-  result = ""
-  for i in issues:
-    var issueText = formatSectionIssue(i, width, indent, verbose)
-    result &= issueText & "\n"
-
-
-proc formatSection(ctx: CliContext, issues: seq[Issue], state: IssueState,
-                   indent = "", verbose = false): string =
-  let innerWidth = adjustedTerminalWidth() - (indent.len * 2)
-
-  result = termColor(fgBlue) &
-    (indent & ".".repeat(innerWidth)) & "\n" &
-    state.displayName.center(adjustedTerminalWidth()) & "\n\n" &
-    termReset
-
-  let issuesByContext = issues.groupBy("context")
-
-  if issues.len > 5 and issuesByContext.len > 1:
-    for context, ctxIssues in issuesByContext:
-
-      result &= termColor(fgYellow) &
-        indent & ctx.getIssueContextDisplayName(context) & ":" &
-        termReset & "\n\n"
-
-      result &= formatSectionIssueList(ctxIssues, innerWidth - 2, indent & "  ", verbose)
-      result &= "\n"
-
-  else: result &= formatSectionIssueList(issues, innerWidth, indent, verbose)
-
-
-proc writeHeader*(ctx: CliContext, header: string) =
-  stdout.setForegroundColor(fgRed, true)
-  stdout.writeLine('_'.repeat(adjustedTerminalWidth()))
-  stdout.writeLine(header.center(adjustedTerminalWidth()))
-  stdout.writeLine('~'.repeat(adjustedTerminalWidth()))
-  stdout.resetAttributes
-
-
-proc list*(
-    ctx: CliContext,
-    filter: Option[IssueFilter],
-    states: Option[seq[IssueState]],
-    showToday = false,
-    showFuture = false,
-    showHidden = false,
-    verbose: bool) =
-
-  if states.isSome:
-    trace "listing issues for " & $states.get
-    for state in states.get:
-      ctx.loadIssues(state)
-      if filter.isSome: ctx.filterIssues(filter.get)
-
-      # Show Done for just today if requested
-      if state == Done and showToday:
-        ctx.issues[Done] = ctx.issues[Done].filterIt(
-          it.hasProp("completed") and
-          sameDay(getTime().local, it.getDateTime("completed")))
-
-      if isatty(stdout):
-        stdout.write ctx.formatSection(ctx.issues[state], state, "", verbose)
-
-      else:
-        stdout.writeLine ctx.issues[state]
-          .mapIt(formatPlainIssueSummary(it))
-          .join("\n")
-
-
-    trace "listing complete"
-    return
-
-  ctx.loadOpenIssues()
-  if filter.isSome:
-    ctx.filterIssues(filter.get)
-    trace "filtered issues"
-
-  let today = showToday and [Current, TodoToday, Pending].anyIt(
-    ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
-
-  let future = showFuture and [Pending, Todo].anyIt(
-    ctx.issues.hasKey(it) and ctx.issues[it].len > 0)
-
-  let indent = if today and future: "  " else: ""
-
-  # Today's items
-  if today:
-    if future: ctx.writeHeader("Today")
-
-    for s in [Current, TodoToday, Pending]:
-      if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
-        let visibleIssues = ctx.issues[s].filterIt(
-          showHidden or
-          not (it.hasProp("hide-until") and
-               it.getDateTime("hide-until") > getTime().local))
-
-        if isatty(stdout):
-          stdout.write ctx.formatSection(visibleIssues, s, indent, verbose)
-
-        else:
-          stdout.writeLine visibleIssues
-            .mapIt(formatPlainIssueSummary(it))
-            .join("\n")
-
-  # Future items
-  if future:
-    if today: ctx.writeHeader("Future")
-
-    let futureCategories =
-      if showToday: @[Todo]
-      else: @[Pending, Todo]
-
-    for s in futureCategories:
-      if ctx.issues.hasKey(s) and ctx.issues[s].len > 0:
-        let visibleIssues = ctx.issues[s].filterIt(
-          showHidden or
-          not (it.hasProp("hide-until") and
-               it.getDateTime("hide-until") > getTime().local))
-
-        if isatty(stdout):
-          stdout.write ctx.formatSection(visibleIssues, s, indent, verbose)
-
-        else:
-          stdout.writeLine visibleIssues
-            .mapIt(formatPlainIssueSummary(it))
-            .join("\n")
-
-  trace "listing complete"

src/pit/sync_pbm_vsb.nim

@@ -1,179 +0,0 @@
-import std/[httpclient, json, jsonutils, logging, options, sets, strutils,
-            terminal, times, tables]
-import timeutils, uuids, zero_functional
-import ./formatting, ./libpit
-
-type
-  PbmVsbSyncContext* = object
-    apiBaseUrl*: string
-    apiToken*: string
-    issueContext*: string
-    pit: PitConfig
-    http: HttpClient
-
-  ServerTask* = object
-    id*: string
-    summary*: string
-    details*: string
-    state*: string
-    lastUpdatedAt*: DateTime
-    archivedAt*: Option[DateTime]
-    tags*: seq[string]
-    parent*: Option[string]
-    priority*: Option[string]
-    project*: Option[string]
-    milestone*: Option[string]
-    hideUntil*: Option[DateTime]
-
-
-proc `%`*(dt: DateTime): JsonNode = %(dt.formatIso8601)
-func toJsonHook(dt: DateTime): JsonNode = %(dt.formatIso8601)
-proc fromJsonHook(dt: var DateTime, n: JsonNode): void =
-  dt = n.getStr.parseIso8601
-
-
-#func `%`*(p: Project): JsonNode = toJson(p)
-func `%`*(t: ServerTask): JsonNode = toJson(t)
-
-
-proc toServerTask(i: Issue): ServerTask =
-  return ServerTask(
-    id: $i.id,
-    summary: i.summary,
-    details: i.details,
-    state: $i.state,
-    tags: i.tags,
-    lastUpdatedAt:
-      if i.hasProp("last-updated"): parseIso8601(i["last-updated"])
-      else: now(),
-    parent:
-      if i.hasProp("parent"): some(i["parent"])
-      else: none[string](),
-    priority:
-      if i.hasProp("priority"): some(i["priority"])
-      else: none[string](),
-    project:
-      if i.hasProp("project"): some(i["project"])
-      else: none[string](),
-    milestone:
-      if i.hasProp("milestone"): some(i["milestone"])
-      else: none[string](),
-    hideUntil:
-      if i.hasProp("hide-until"): some(parseIso8601(i["hide-until"]))
-      else: none[DateTime]())
-
-
-func getOrFail(n: JsonNode, k: string): JsonNode =
-  if not n.hasKey(k):
-    raise newException(ValueError, "missing key '" & k & "'")
-  return n[k]
-
-
-proc initSyncContext*(pit: PitConfig, syncConfig: JsonNode): PbmVsbSyncContext =
-  result.pit = pit
-  result.apiBaseUrl = syncConfig.getOrFail("apiBaseUrl").getStr
-  result.apiToken = syncConfig.getOrFail("apiToken").getStr
-  result.issueContext = syncConfig.getOrFail("context").getStr
-  result.http = newHttpClient()
-  result.http.headers = newHttpHeaders({ "Authorization": "Bearer " & result.apiToken })
-
-
-proc fetchServerTasks*(ctx: PbmVsbSyncContext): seq[ServerTask] =
-  result = newSeq[ServerTask]()
-  let url = ctx.apiBaseUrl & "/tasks"
-
-  debug "Fetching tasks from server:\n\t" & url
-  let resp = ctx.http.get(url)
-  if resp.status != "200":
-    debug("Received " & resp.status & ": " & resp.body)
-    raise newException(Exception, "Failed to fetch tasks from server")
-  fromJson(result, parseJson(resp.body)["data"])
-
-
-proc updateTask*(ctx: PbmVsbSyncContext, task: ServerTask): void =
-  let url = ctx.apiBaseUrl & "/task" & task.id
-  let body = %task
-  let resp = ctx.http.post(url, $body)
-  if resp.status != "200":
-    debug("Received " & resp.status & ": " & resp.body)
-    raise newException(Exception, "Failed to update task " & task.id & "on server")
-
-
-proc updateTasks*(ctx: PbmVsbSyncContext, tasks: seq[ServerTask]): void =
-  let url = ctx.apiBaseUrl & "/tasks"
-  let body = %tasks
-  let resp = ctx.http.put(url, $body)
-  if resp.status != "200":
-    debug("Received " & resp.status & ": " & resp.body)
-    raise newException(Exception, "Failed to update tasks on server")
-
-
-proc deleteTask*(ctx: PbmVsbSyncContext, taskId: string): void =
-  let url = ctx.apiBaseUrl & "/tasks/" & taskId
-  let resp = ctx.http.delete(url)
-  if resp.status != "200":
-    debug("Received " & resp.status & ": " & resp.body)
-    raise newException(Exception, "Failed to delete task " & taskId & " on server")
-
-
-proc sync*(
-    ctx: PbmVsbSyncContext,
-    dryRun = true,
-    batchSize = 100): void =
-
-  # We're going to do a uni-directional sync, pushing local issues to the
-  # server. However, we only want to update issues that have changed since
-  # the last sync based on the *last-updated* property.
-
-  # Note that all the logic assumes the server only has one context of tasks.
-  # If this ever changes, this logic will need to change.
-  let filter = propsFilter(newTable({ "context": ctx.issueContext }))
-  let allIssues = ctx.pit.tasksDir.loadAllIssues()
-
-  var issues = newSeq[Issue]()
-  for state in allIssues.keys:
-    issues.add(allIssues[state].filter(filter))
-
-  let serverTasks = fetchServerTasks(ctx)
-  debug "Loaded $# server tasks" % [$serverTasks.len]
-  var issuesToPush = newSeq[ServerTask]()
-
-  var unmatchedServerTaskIds = toHashSet(serverTasks --> map(it.id))
-
-  # Process all local issues
-  info "Updating the following tasks for context " & ctx.issueContext
-  for lentIssue in issues:
-    let i = lentIssue
-    let foundTask = serverTasks --> find(it.id == $i.id)
-
-    if foundTask.isSome:
-      # There is a server task for this issue
-      unmatchedServerTaskIds.excl(foundTask.get.id)
-
-      if i.hasProp("last-updated"):
-        var localUpdate = parseIso8601(i["last-updated"])
-        localUpdate.nanosecond = 0
-        if  foundTask.get.lastUpdatedAt >= localUpdate:
-          # but we don't have any update
-          continue
-
-    # We fell through the conditional block above, so either there isn't a
-    # server task, or we *do* have an update,
-    issuesToPush.add(toServerTask(i))
-    info "  " & formatSectionIssue(i, width = terminalWidth() - 8)
-
-  # Now archive the issues on the server that we didn't see locally.
-  info "Archiving the following tasks for context " & ctx.issueContext
-  for task in serverTasks:
-    var toArchive = task
-    if unmatchedServerTaskIds.contains(task.id) and
-       toArchive.archivedAt.isNone:
-      toArchive.archivedAt = some(now())
-      issuesToPush.add(toArchive)
-
-  if not dryRun:
-    var offset = 0
-    while (offset < issuesToPush.len):
-      let batchSize = min(issuesToPush.len - offset, batchSize)
-      updateTasks(ctx, issuesToPush[offset ..< offset + batchSize])
-      offset += batchSize

src/pit_api.nim

@@ -1,17 +1,12 @@
 ## Personal Issue Tracker API Interface
 ## ====================================
-#
-# **NOTE** This is currently not being built as it no longer works under Nim
-# 2.x due to the inability to call system calls (invoke pit via cli) in a
-# gc-safe manner. It should be rewritten to use the functionality exposed by
-# libpit directly rather than calling the pit cli executable. Unfortunately
-# this would require a non-trivial rewrite.
 
 import asyncdispatch, cliutils, docopt, jester, json, logging, options, sequtils, strutils
 import nre except toSeq
 
-import pit/libpit
+import pitpkg/private/libpit
-import pit/cliconstants
+
+include "pitpkg/version.nim"
 
 type
   PitApiCfg* = object
@@ -25,7 +20,7 @@ proc raiseEx(reason: string): void = raise newException(Exception, reason)
 
 template halt(code: HttpCode,
               headers: RawHeaders,
-              content: string): void =
+              content: string): typed =
   ## Immediately replies with the specified request. This means any further
   ## code will not be executed after calling this template in the current
   ## route.
@@ -45,10 +40,10 @@ template checkAuth(cfg: PitApiCfg) =
   var authed {.inject.} = false
 
   try:
-    if not headers(request).hasKey("Authorization"):
+    if not request.headers.hasKey("Authorization"):
       raiseEx "No auth token."
 
-    let headerVal = headers(request)["Authorization"]
+    let headerVal = request.headers["Authorization"]
     if not headerVal.startsWith("Bearer "):
       raiseEx "Invalid Authentication type (only 'Bearer' is supported)."
 

src/pitpkg/private/libpit.nim

@@ -1,9 +1,7 @@
-import std/[json, logging, options, os, strformat, strutils, tables, times]
+import cliutils, docopt, json, logging, langutils, options, os, ospaths,
-import cliutils, docopt, langutils, uuids, zero_functional
+  sequtils, strutils, tables, times, timeutils, uuids
 
-import nre except toSeq
+from nre import find, match, re, Regex
-import timeutils except `>`
-from sequtils import deduplicate, toSeq
 
 type
   Issue* = ref object
@@ -12,7 +10,6 @@ type
     summary*, details*: string
     properties*: TableRef[string, string]
     tags*: seq[string]
-    state*: IssueState
 
   IssueState* = enum
     Current = "current",
@@ -25,49 +22,16 @@ type
   IssueFilter* = ref object
     completedRange*: Option[tuple[b, e: DateTime]]
     fullMatch*, summaryMatch*: Option[Regex]
-    hasTags*: seq[string]
-    exclTags*: seq[string]
     properties*: TableRef[string, string]
-    exclProperties*: TableRef[string, seq[string]]
 
   PitConfig* = ref object
     tasksDir*: string
     contexts*: TableRef[string, string]
-    autoSync*: bool
-    syncTargets*: seq[JsonNode]
     cfg*: CombinedConfig
 
-  CliContext* = ref object
-    cfg*: PitConfig
-    contexts*: TableRef[string, string]
-    defaultContext*: Option[string]
-    issues*: TableRef[IssueState, seq[Issue]]
-    triggerPtk*, verbose*: bool
-
-  Recurrence* = object
-    cloneId*: Option[string]
-    interval*: TimeInterval
-    isFromCompletion*: bool
-
-
 const DONE_FOLDER_FORMAT* = "yyyy-MM"
-const ISO8601_MS = "yyyy-MM-dd'T'HH:mm:ss'.'fffzzz"
 
 let ISSUE_FILE_PATTERN = re"[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}\.txt"
-let RECURRENCE_PATTERN = re"(every|after) ((\d+) )?((hour|day|week|month|year)s?)(, ([0-9a-fA-F]+))?"
-
-let traceStartTime = cpuTime()
-var lastTraceTime = traceStartTime
-
-proc trace*(msg: string, diffFromLast = false) =
-  let curTraceTime = cpuTime()
-
-  if diffFromLast:
-    debug &"{(curTraceTime - lastTraceTime) * 1000:6.2f}ms {msg}"
-  else:
-    debug &"{cpuTime() - traceStartTime:08.4f} {msg}"
-
-  lastTraceTime = curTraceTime
 
 proc displayName*(s: IssueState): string =
   case s
@@ -78,11 +42,6 @@ proc displayName*(s: IssueState): string =
   of Todo: result = "Todo"
   of TodoToday: result = "Todo"
 
-
-proc sameDay*(a, b: DateTime): bool =
-  result = a.year == b.year and a.yearday == b.yearday
-
-
 ## Allow issue properties to be accessed as if the issue was a table
 proc `[]`*(issue: Issue, key: string): string =
   return issue.properties[key]
@@ -90,8 +49,6 @@ proc `[]`*(issue: Issue, key: string): string =
 proc `[]=`*(issue: Issue, key: string, value: string) =
   issue.properties[key] = value
 
-
-## Issue property accessors
 proc hasProp*(issue: Issue, key: string): bool =
   return issue.properties.hasKey(key)
 
@@ -105,41 +62,12 @@ proc getDateTime*(issue: Issue, key: string, default: DateTime): DateTime =
 proc setDateTime*(issue: Issue, key: string, dt: DateTime) =
   issue.properties[key] = dt.formatIso8601
 
-proc getRecurrence*(issue: Issue): Option[Recurrence] =
-  if not issue.hasProp("recurrence"): return none[Recurrence]()
-
-  let m = issue["recurrence"].match(RECURRENCE_PATTERN)
-
-  if not m.isSome:
-    warn "not a valid recurrence value: '" & issue["recurrence"] & "'"
-    return none[Recurrence]()
-
-  let c = nre.toSeq(m.get.captures)
-  let timeVal = if c[2].isSome: c[2].get.parseInt
-                else: 1
-  return some(Recurrence(
-    isFromCompletion: c[0].get == "after",
-    interval:
-      case c[4].get:
-        of "hour": hours(timeVal)
-        of "day": days(timeVal)
-        of "week": weeks(timeVal)
-        of "month": months(timeVal)
-        of "year": years(timeVal)
-        else: weeks(1),
-    cloneId: c[6]))
-
-
-## Issue filtering
 proc initFilter*(): IssueFilter =
   result = IssueFilter(
     completedRange: none(tuple[b, e: DateTime]),
     fullMatch: none(Regex),
     summaryMatch: none(Regex),
-    hasTags: @[],
+    properties: newTable[string, string]())
-    exclTags: @[],
-    properties: newTable[string, string](),
-    exclProperties: newTable[string,seq[string]]())
 
 proc propsFilter*(props: TableRef[string, string]): IssueFilter =
   if isNil(props):
@@ -161,10 +89,6 @@ proc fullMatchFilter*(pattern: string): IssueFilter =
   result = initFilter()
   result.fullMatch = some(re("(?i)" & pattern))
 
-proc hasTagsFilter*(tags: seq[string]): IssueFilter =
-  result = initFilter()
-  result.hasTags = tags
-
 proc groupBy*(issues: seq[Issue], propertyKey: string): TableRef[string, seq[Issue]] =
   result = newTable[string, seq[Issue]]()
   for i in issues:
@@ -173,24 +97,6 @@ proc groupBy*(issues: seq[Issue], propertyKey: string): TableRef[string, seq[Iss
     result[key].add(i)
 
 
-## Parse and format dates
-const DATE_FORMATS = [
-  "MM/dd",
-  "MM-dd",
-  "yyyy-MM-dd",
-  "yyyy/MM/dd",
-  "yyyy-MM-dd'T'hh:mm:ss"
-]
-proc parseDate*(d: string): DateTime =
-  var errMsg = ""
-  for df in DATE_FORMATS:
-    try: return d.parse(df)
-    except CatchableError:
-      errMsg &= "\n\tTried " & df & " with " & d
-      continue
-  raise newException(ValueError, "Unable to parse input as a date: " & d & errMsg)
-
-
 ## Parse and format issues
 proc fromStorageFormat*(id: string, issueTxt: string): Issue =
   type ParseState = enum ReadingSummary, ReadingProps, ReadingDetails
@@ -214,7 +120,7 @@ proc fromStorageFormat*(id: string, issueTxt: string): Issue =
 
     of ReadingProps:
       # Ignore empty lines
-      if line.isEmptyOrWhitespace: continue
+      if line.isNilOrWhitespace: continue
 
       # Look for the sentinal to start parsing as detail lines
       if line == "--------":
@@ -222,13 +128,12 @@ proc fromStorageFormat*(id: string, issueTxt: string): Issue =
         continue
 
 
-      let parts = line.split({':'}, 1) --> map(it.strip())
+      let parts = line.split({':'}, 1).mapIt(it.strip())
       if parts.len != 2:
         raise newException(ValueError, "unable to parse property line: " & line)
 
       # Take care of special properties: `tags`
-      if parts[0] == "tags":
+      if parts[0] == "tags": result.tags = parts[1].split({','}).mapIt(it.strip())
-        result.tags = parts[1].split({','}) --> map(it.strip())
       else: result[parts[0]] = parts[1]
 
     of ReadingDetails:
@@ -238,35 +143,24 @@ proc fromStorageFormat*(id: string, issueTxt: string): Issue =
 
 proc toStorageFormat*(issue: Issue, withComments = false): string =
   var lines: seq[string] = @[]
-
   if withComments: lines.add("# Summary (one line):")
   lines.add(issue.summary)
-
   if withComments: lines.add("# Properties (\"key:value\" per line):")
-  issue.properties["last-updated"] = now().format(ISO8601_MS)
   for key, val in issue.properties:
-    if not val.isEmptyOrWhitespace: lines.add(key & ": " & val)
+    if not val.isNilOrWhitespace: lines.add(key & ": " & val)
-
   if issue.tags.len > 0: lines.add("tags: " & issue.tags.join(","))
-
+  if not isNilOrWhitespace(issue.details) or withComments:
-  if not isEmptyOrWhitespace(issue.details) or withComments:
     if withComments: lines.add("# Details go below the \"--------\"")
     lines.add("--------")
     lines.add(issue.details)
 
   result = lines.join("\n")
 
-
 ## Load and store from filesystem
 proc loadIssue*(filePath: string): Issue =
   result = fromStorageFormat(splitFile(filePath).name, readFile(filePath))
   result.filepath = filePath
 
-  let parentDirName = filePath.splitFile().dir.splitFile().name
-  let issueState = IssueState.items.toSeq --> find($it == parentDirName)
-  if issueState.isSome: result.state = issueState.get
-  else: result.state = IssueState.Done
-
 proc loadIssueById*(tasksDir, id: string): Issue =
   for path in walkDirRec(tasksDir):
     if path.splitFile.name.startsWith(id):
@@ -274,7 +168,6 @@ proc loadIssueById*(tasksDir, id: string): Issue =
   raise newException(KeyError, "cannot find issue for id: " & id)
 
 proc store*(issue: Issue, withComments = false) =
-  discard existsOrCreateDir(issue.filePath.parentDir)
   writeFile(issue.filepath, toStorageFormat(issue, withComments))
 
 proc store*(tasksDir: string, issue: Issue, state: IssueState, withComments = false) =
@@ -302,14 +195,12 @@ proc storeOrder*(issues: seq[Issue], path: string) =
 proc loadIssues*(path: string): seq[Issue] =
   let orderFile = path / "order.txt"
 
-  trace "loading issues under " & path
-
   let orderedIds =
     if fileExists(orderFile):
-      (orderFile.lines.toSeq -->
+      toSeq(orderFile.lines)
-        map(it.split(' ')[0]).
+        .mapIt(it.split(' ')[0])
-        filter(not it.startsWith("> ") and not it.isEmptyOrWhitespace)).
+        .deduplicate
-        deduplicate()
+        .filterIt(not it.startsWith("> ") and not it.isNilOrWhitespace)
     else: newSeq[string]()
 
   type TaggedIssue = tuple[issue: Issue, ordered: bool]
@@ -319,7 +210,6 @@ proc loadIssues*(path: string): seq[Issue] =
     if extractFilename(path).match(ISSUE_FILE_PATTERN).isSome():
       unorderedIssues.add((loadIssue(path), false))
 
-  trace "loaded " & $unorderedIssues.len & " issues", true
   result = @[]
 
   # Add all ordered issues in order
@@ -334,182 +224,84 @@ proc loadIssues*(path: string): seq[Issue] =
     if taggedIssue.ordered: continue
     result.add(taggedIssue.issue)
 
-  trace "ordered the loaded issues", true
-
   # Finally, save current order
   result.storeOrder(path)
 
-proc loadIssues*(tasksDir: string, state: IssueState): seq[Issue] =
-  loadIssues(tasksDir / $state)
-
-proc loadAllIssues*(tasksDir: string): TableRef[IssueState, seq[Issue]] =
-  result = newTable[IssueState, seq[Issue]]()
-  for state in IssueState: result[state] = tasksDir.loadIssues(state)
-
 proc changeState*(issue: Issue, tasksDir: string, newState: IssueState) =
-  var dbgInfo = "[$#] changing state: $# → $#" %
-    [ ($issue.id)[0..<6], $issue.state, $newState ]
-
   let oldFilepath = issue.filepath
   if newState == Done: issue.setDateTime("completed", getTime().local)
   tasksDir.store(issue, newState)
   if oldFilePath != issue.filepath: removeFile(oldFilepath)
-  dbgInfo &= "\n\told path: $#\n\tnew path: $#" % [oldFilePath, issue.filepath]
-  issue.state = newState
-  debug dbgInfo
 
 proc delete*(issue: Issue) = removeFile(issue.filepath)
 
-proc nextRecurrence*(tasksDir: string, rec: Recurrence, defaultIssue: Issue): Issue =
-  let baseIssue = if rec.cloneId.isSome: tasksDir.loadIssueById(rec.cloneId.get)
-                  else: defaultIssue
-
-  let newProps = newTable[string,string]()
-  for k, v in baseIssue.properties:
-    if k != "completed": newProps[k] = v
-  newProps["prev-recurrence"] = $baseIssue.id
-
-  result = Issue(
-    id: genUUID(),
-    state: baseIssue.state,
-    summary: baseIssue.summary,
-    properties: newProps,
-    tags: baseIssue.tags)
-
-  let now = getTime().local
-
-  let startDate =
-    if rec.isFromCompletion:
-      if baseIssue.hasProp("completed"): baseIssue.getDateTime("completed")
-      else: now
-    else:
-      if baseIssue.hasProp("created"): baseIssue.getDateTime("created")
-      else: now
-
-  # walk the calendar until the next recurrence that is after the current time.
-  var nextTime = startDate + rec.interval
-  while now > nextTime: nextTime += rec.interval
-
-  result.setDateTime("hide-until", nextTime)
-
-
 ## Utilities for working with issue collections.
 proc filter*(issues: seq[Issue], filter: IssueFilter): seq[Issue] =
-  var f: seq[Issue] = issues
+  result = issues
 
   for k,v in filter.properties:
-    f = f --> filter(it.hasProp(k) and it[k] == v)
+    result = result.filterIt(it.hasProp(k) and it[k] == v)
-
-  for k,v in filter.exclProperties:
-    f = f --> filter(not (it.hasProp(k) and v.contains(it[k])))
 
   if filter.completedRange.isSome:
     let range = filter.completedRange.get
-    f = f --> filter(
+    result = result.filterIt(
              not it.hasProp("completed") or
              it.getDateTime("completed").between(range.b, range.e))
 
   if filter.summaryMatch.isSome:
     let p = filter.summaryMatch.get
-    f = f --> filter(it.summary.find(p).isSome)
+    result = result.filterIt(it.summary.find(p).isSome)
 
   if filter.fullMatch.isSome:
     let p = filter.fullMatch.get
-    f = f -->
+    result = result.filterIt( it.summary.find(p).isSome or it.details.find(p).isSome)
-      filter(it.summary.find(p).isSome or it.details.find(p).isSome)
-
-  for tagLent in filter.hasTags:
-    let tag = tagLent
-    f = f --> filter(it.tags.find(tag) >= 0)
-
-  for exclTagLent in filter.exclTags:
-    let exclTag = exclTagLent
-    f = f --> filter(it.tags.find(exclTag) < 0)
-
-  return f # not using result because zero_functional doesn't play nice with it
-
-proc find*(
-    issues: TableRef[IssueState, seq[Issue]],
-    filter: IssueFilter
-  ): seq[Issue] =
-
-  result = @[]
-  for stateIssues in issues.values: result &= stateIssues.filter(filter)
-
 
 ### Configuration utilities
 proc loadConfig*(args: Table[string, Value] = initTable[string, Value]()): PitConfig =
-  var pitrcFilename: string
+  let pitrcLocations = @[
+    if args["--config"]: $args["--config"] else: "",
+    ".pitrc", $getEnv("PITRC"), $getEnv("HOME") & "/.pitrc"]
 
-  try:
+  var pitrcFilename: string =
-    pitrcFilename = findConfigFile(".pitrc",
+    foldl(pitrcLocations, if len(a) > 0: a elif existsFile(b): b else: "")
-      if args["--config"]: @[$args["--config"]] else: @[])
+
-  except ValueError:
+  if not existsFile(pitrcFilename):
-    warn "could not find .pitrc file: " & pitrcFilename
+    warn "pit: could not find .pitrc file: " & pitrcFilename
-    if isEmptyOrWhitespace(pitrcFilename):
+    if isNilOrWhitespace(pitrcFilename):
       pitrcFilename = $getEnv("HOME") & "/.pitrc"
     var cfgFile: File
     try:
       cfgFile = open(pitrcFilename, fmWrite)
       cfgFile.write("{\"tasksDir\": \"/path/to/tasks\"}")
-    except CatchableError: warn "could not write default .pitrc to " & pitrcFilename
+    except: warn "pit: could not write default .pitrc to " & pitrcFilename
     finally: close(cfgFile)
 
-  debug "loading config from '$#'" % [pitrcFilename]
+  var cfgJson: JsonNode
-  let cfg = initCombinedConfig(pitrcFilename, args)
+  try: cfgJson = parseFile(pitrcFilename)
+  except: raise newException(IOError,
+    "unable to read config file: " & pitrcFilename &
+    "\x0D\x0A" & getCurrentExceptionMsg())
+
+  let cfg = CombinedConfig(docopt: args, json: cfgJson)
 
   result = PitConfig(
     cfg: cfg,
-    autoSync: parseBool(cfg.getVal("auto-sync", "false")),
     contexts: newTable[string,string](),
-    tasksDir: cfg.getVal("tasks-dir", ""),
+    tasksDir: cfg.getVal("tasks-dir", ""))
-    syncTargets: cfg.getJson("sync-targets", newJArray()).getElems)
 
-  for k, v in cfg.getJson("contexts", newJObject()):
+  if cfgJson.hasKey("contexts"):
-    result.contexts[k] = v.getStr()
+    for k, v in cfgJson["contexts"]:
+      result.contexts[k] = v.getStr()
 
-  if isEmptyOrWhitespace(result.tasksDir):
+  if isNilOrWhitespace(result.tasksDir):
     raise newException(Exception, "no tasks directory configured")
 
-  if not dirExists(result.tasksDir):
+  if not existsDir(result.tasksDir):
     raise newException(Exception, "cannot find tasks dir: " & result.tasksDir)
 
   # Create our tasks directory structure if needed
   for s in IssueState:
-    if not dirExists(result.tasksDir / $s):
+    if not existsDir(result.tasksDir / $s):
       (result.tasksDir / $s).createDir
 
 
-## CliContext functionality
-proc initContext*(args: Table[string, Value]): CliContext =
-  let pitCfg = loadConfig(args)
-
-  let cliJson =
-    if pitCfg.cfg.json.hasKey("cli"): pitCfg.cfg.json["cli"]
-    else: newJObject()
-
-  let cliCfg = CombinedConfig(docopt: args, json: cliJson)
-
-  result = CliContext(
-    cfg: pitCfg,
-    contexts: pitCfg.contexts,
-    defaultContext:
-      if not cliJson.hasKey("defaultContext"): none(string)
-      else: some(cliJson["defaultContext"].getStr()),
-    verbose: parseBool(cliCfg.getVal("verbose", "false")) and not args["--quiet"],
-    issues: newTable[IssueState, seq[Issue]](),
-    triggerPtk: cliJson.getOrDefault("triggerPtk").getBool(false))
-
-proc loadIssues*(ctx: CliContext, state: IssueState) =
-  ctx.issues[state] = loadIssues(ctx.cfg.tasksDir, state)
-
-proc loadOpenIssues*(ctx: CliContext) =
-  ctx.issues = newTable[IssueState, seq[Issue]]()
-  for state in [Current, TodoToday, Todo, Pending, Todo]: ctx.loadIssues(state)
-
-proc loadAllIssues*(ctx: CliContext) =
-  ctx.issues = ctx.cfg.tasksDir.loadAllIssues()
-
-proc filterIssues*(ctx: CliContext, filter: IssueFilter) =
-  for state, issueList in ctx.issues:
-    ctx.issues[state] = issueList.filter(filter)

src/pitpkg/version.nim

@@ -0,0 +1 @@
+const PIT_VERSION* = "4.6.0"