corvee 0.1.0__py3-none-any.whl

corvee/__init__.py

@@ -0,0 +1,11 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+from importlib.metadata import version
+
+__version__ = version("corvee")
+
+__all__ = ["__version__"]

corvee/__main__.py

@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+from corvee.cli.main import main
+
+if __name__ == "__main__":
+    main()

corvee/actor.py

@@ -0,0 +1,40 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import getpass
+import os
+
+import click
+
+
+def _flag_value(name: str) -> str | None:
+    """The global --actor/--session-id value from the running CLI invocation,
+    if any. None outside a click context (e.g. calling these functions
+    directly in a test) or when the flag was not passed.
+    """
+    ctx = click.get_current_context(silent=True)
+    if ctx is None:
+        return None
+    return ctx.find_root().params.get(name)
+
+
+def resolve_actor(override: str | None = None) -> str:
+    """--actor if given (explicitly, or via the running CLI's --actor flag),
+    else CORVEE_ACTOR if set, else human:$USER.
+    """
+    actor = override or _flag_value("actor") or os.environ.get("CORVEE_ACTOR")
+    if actor:
+        return actor
+    user = os.environ.get("USER") or getpass.getuser()
+    return f"human:{user}"
+
+
+def resolve_session_id(override: str | None = None) -> str | None:
+    """--session-id if given (explicitly, or via the running CLI's
+    --session-id flag), else CORVEE_SESSION_ID if set and non-empty, else
+    None.
+    """
+    return override or _flag_value("session_id") or os.environ.get("CORVEE_SESSION_ID") or None

corvee/cli/__init__.py

@@ -0,0 +1,9 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+from corvee.cli.main import cli
+
+__all__ = ["cli"]

corvee/cli/commands/__init__.py

@@ -0,0 +1,5 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#

corvee/cli/commands/brief.py

@@ -0,0 +1,186 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import json
+import sqlite3
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, cast
+
+import click
+
+from corvee.actor import resolve_actor
+from corvee.cli.context import corvee_context
+from corvee.cli.scope import fetch_merged, sort_tasks
+from corvee.config import project_exists
+from corvee.constants import (
+    DEFAULT_STALE_DURATION,
+    LIST_TABLE_DEFAULT_FIELDS,
+    SCOPE_FILTERS,
+    Scope,
+    ScopeFilter,
+)
+from corvee.db.events import get_last_comment
+from corvee.db.labels import list_labels_with_counts
+from corvee.db.tasks import TaskFilter, TaskRow, list_tasks, mine_tasks, ready_tasks
+from corvee.output import render_table
+from corvee.timeutil import parse_duration, timestamp
+
+READY_LIMIT = 5
+
+EPILOG = """\
+\b
+Examples:
+Reorient at the start of a session in one call:
+  corvee brief
+Get the same snapshot as machine-readable output:
+  corvee brief --json
+See the machine-wide backlog alongside this project's:
+  corvee brief --scope all --json
+Check only what's filed in the shared global database:
+  corvee brief --scope global --json
+"""
+
+
+def mine_section(
+    scope_filter: ScopeFilter,
+    *,
+    actor: str | None = None,
+    project_db_path: Path | None = None,
+    local_available: bool | None = None,
+) -> list[dict[str, Any]]:
+    """Open tasks claimed by (or assigned and unclaimed to) `actor`, each
+    with its last comment. `actor`, omitted, resolves ambiently
+    (`resolve_actor()`, the CLI's own `$CORVEE_ACTOR`/`--actor`); the MCP
+    surface passes its already-resolved `ServerConfig.actor` instead
+    (spec §10.1). `project_db_path`/`local_available`, given, thread
+    through to `fetch_merged` the same way -- `project_db_path` is the MCP
+    surface's own already-resolved project db path, used verbatim instead
+    of a fresh `resolve_project` per call (TASK-37).
+    """
+    resolved_actor = actor or resolve_actor()
+
+    def fetch(conn: sqlite3.Connection, s: Scope) -> list[tuple[TaskRow, dict[str, Any] | None]]:
+        tasks = mine_tasks(conn, resolved_actor, scope=s)
+        return [(task, get_last_comment(conn, task.id)) for task in tasks]
+
+    pairs = fetch_merged(
+        scope_filter,
+        fetch,
+        actor=resolved_actor,
+        project_db_path=project_db_path,
+        local_available=local_available,
+    )
+    pairs.sort(key=lambda p: p[0].id, reverse=True)
+    pairs.sort(key=lambda p: p[0].claimed_at or "", reverse=True)
+    results = []
+    for task, last_comment in pairs:
+        detail = task.to_dict()
+        detail["last_comment"] = last_comment
+        results.append(detail)
+    return results
+
+
+def ready_section(
+    scope_filter: ScopeFilter,
+    *,
+    actor: str | None = None,
+    project_db_path: Path | None = None,
+    local_available: bool | None = None,
+) -> list[dict[str, Any]]:
+    """Up to `READY_LIMIT` unclaimed, open, unblocked tasks. See
+    `mine_section` for the `actor`/`project_db_path`/`local_available`
+    parameters.
+    """
+    tasks = sort_tasks(
+        fetch_merged(
+            scope_filter,
+            lambda conn, s: ready_tasks(conn, scope=s),
+            actor=actor,
+            project_db_path=project_db_path,
+            local_available=local_available,
+        )
+    )
+    return [t.to_dict() for t in tasks[:READY_LIMIT]]
+
+
+def stale_section(
+    scope_filter: ScopeFilter,
+    *,
+    actor: str | None = None,
+    project_db_path: Path | None = None,
+    local_available: bool | None = None,
+) -> list[dict[str, Any]]:
+    """Tasks whose claim has gone stale. See `mine_section` for the
+    `actor`/`project_db_path`/`local_available` parameters.
+    """
+    cutoff = timestamp(datetime.now(UTC) - parse_duration(DEFAULT_STALE_DURATION))
+    filt = TaskFilter(stale_before=cutoff)
+    tasks = sort_tasks(
+        fetch_merged(
+            scope_filter,
+            lambda conn, s: list_tasks(conn, filt, scope=s),
+            actor=actor,
+            project_db_path=project_db_path,
+            local_available=local_available,
+        )
+    )
+    return [t.to_dict() for t in tasks]
+
+
+def labels_section(
+    *,
+    actor: str | None = None,
+    project_db_path: Path | None = None,
+    has_project: bool | None = None,
+) -> list[dict[str, Any]]:
+    """The local project's label vocabulary — never merged across scope,
+    the same restriction `task labels` already has (§3.3).
+
+    Empty, not an error, when no local project resolves — `brief`'s other
+    three sections already degrade the same way for a purely-global call
+    (§3.3), and `labels` is an auxiliary section of that same call, not a
+    separate ask for local data the way standalone `task labels` is.
+    `has_project`, given, is used verbatim instead of the ambient
+    `project_exists()` check, the same override `mine_section` and its
+    siblings take as `local_available`. `project_db_path`, given, is
+    `corvee_context`'s own override, same as its sibling sections.
+    """
+    available = project_exists() if has_project is None else has_project
+    if not available:
+        return []
+    with corvee_context(write=False, actor=actor, project_db_path=project_db_path) as ctx:
+        rows = list_labels_with_counts(ctx.conn)
+    return [{"name": name, "task_count": count} for name, count in rows]
+
+
+@click.command(epilog=EPILOG)
+@click.option("--scope", "-s", "scope_filter", type=click.Choice(SCOPE_FILTERS), default="all")
+@click.option("--json", "-j", "as_json", is_flag=True)
+def brief(scope_filter: str, as_json: bool) -> None:
+    """Session-start snapshot: what's claimed, what's ready, what's gone stale.
+
+    Combines `task mine`, `task ready` and `task list --stale` into one
+    read-only call.
+    """
+    scope = cast(ScopeFilter, scope_filter)
+    sections = {
+        "mine": mine_section(scope),
+        "ready": ready_section(scope),
+        "stale": stale_section(scope),
+        "labels": labels_section(),
+    }
+    if as_json:
+        click.echo(json.dumps(sections))
+        return
+    blocks = [
+        f"{name}:\n{render_table(rows, default_fields=LIST_TABLE_DEFAULT_FIELDS)}"
+        for name, rows in sections.items()
+        if name != "labels" and rows
+    ]
+    if sections["labels"]:
+        blocks.append(f"labels:\n{render_table(sections['labels'], fields=('name', 'task_count'))}")
+    click.echo("\n\n".join(blocks))

corvee/cli/commands/completion.py

@@ -0,0 +1,47 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import click
+import click.shell_completion
+
+_COMPLETE_VAR = "_CORVEE_COMPLETE"
+_SHELLS = ("bash", "zsh", "fish")
+
+EPILOG = """\
+\b
+Examples:
+Print the bash activation script, to inspect before trusting it:
+  corvee completion bash
+Print the zsh script instead:
+  corvee completion zsh
+Print the fish script instead:
+  corvee completion fish
+
+Enable it by `eval`ing the output, e.g. once per shell session:
+  eval "$(corvee completion bash)"
+Or permanently, by adding the same line to your shell's rc file:
+  echo 'eval "$(corvee completion bash)"' >> ~/.bashrc
+"""
+
+
+@click.command(epilog=EPILOG)
+@click.argument("shell", type=click.Choice(_SHELLS))
+def completion(shell: str) -> None:
+    """Print a shell completion script; `eval` its output to enable it.
+
+    Covers subcommand and flag names, click.Choice values (--state,
+    --priority, ...), and TASK-<n>/FACT-<n> arguments completed against
+    real ids in the current project.
+    """
+    # Deferred import: corvee.cli.main imports this module to register the
+    # command, so importing it back at module load time would be circular.
+    from corvee.cli.main import cli as root_cli
+
+    comp_cls = click.shell_completion.get_completion_class(shell)
+    if comp_cls is None:
+        # Unreachable: click.Choice(_SHELLS) already restricts to known shells.
+        raise AssertionError(f"no completion support for shell {shell!r}")
+    click.echo(comp_cls(root_cli, {}, "corvee", _COMPLETE_VAR).source())

corvee/cli/commands/doctor.py

@@ -0,0 +1,141 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import click
+
+from corvee.cli.context import corvee_context
+from corvee.config import global_db_path, project_exists
+from corvee.constants import DEFAULT_STALE_DURATION, Scope
+from corvee.db.connection import open_connection
+from corvee.db.schema import CURRENT_SCHEMA_VERSION
+from corvee.db.stats import integrity_findings, project_stats
+from corvee.timeutil import parse_duration, timestamp
+
+EPILOG = """\
+\b
+Examples:
+Check the project's overall health at a glance:
+  corvee doctor
+Get the same report as machine-readable output:
+  corvee doctor --json
+Flag claims idle for over an hour as stale:
+  corvee doctor --stale 1h --json
+"""
+
+
+def _stats_lines(stats: dict[str, Any], *, prefix: str = "") -> list[str]:
+    return [
+        f"{prefix}tasks.total: {stats['tasks']['total']}",
+        *(
+            f"{prefix}tasks.by_state.{state}: {count}"
+            for state, count in stats["tasks"]["by_state"].items()
+        ),
+        f"{prefix}tasks.claimed: {stats['tasks']['claimed']}",
+        f"{prefix}tasks.stale: {stats['tasks']['stale']}",
+        f"{prefix}facts.total: {stats['facts']['total']}",
+        *(
+            f"{prefix}facts.by_status.{status}: {count}"
+            for status, count in stats["facts"]["by_status"].items()
+        ),
+        f"{prefix}labels: {stats['labels']}",
+    ]
+
+
+def _findings_lines(findings: list[dict[str, Any]], *, prefix: str = "") -> list[str]:
+    if not findings:
+        return [f"{prefix}findings: none"]
+    lines = [f"{prefix}findings:"]
+    for finding in findings:
+        if finding["kind"] == "cycle":
+            lines.append(f"  {finding['relation']} cycle: {' -> '.join(finding['task_ids'])}")
+        else:
+            lines.append(
+                f"  dangling foreign key: {finding['table']}.rowid={finding['rowid']}"
+                f" -> {finding['references']}"
+            )
+    return lines
+
+
+def _render_text(payload: dict[str, Any]) -> str:
+    lines = [f"schema_version: {payload['schema_version']}"]
+
+    local_payload = payload["local"]
+    if local_payload is None:
+        lines.append("local: not initialized in this directory (no .corvee/config.toml found)")
+    else:
+        lines.append(f"local.db_path: {local_payload['db_path']}")
+        lines.extend(_stats_lines(local_payload, prefix="local."))
+        lines.extend(_findings_lines(local_payload["findings"], prefix="local."))
+
+    global_payload = payload["global"]
+    if global_payload is None:
+        lines.append("global: not created yet (no --global task or fact filed)")
+    else:
+        lines.append(f"global.db_path: {global_payload['db_path']}")
+        lines.extend(_stats_lines(global_payload, prefix="global."))
+        lines.extend(_findings_lines(global_payload["findings"], prefix="global."))
+    return "\n".join(lines)
+
+
+def _db_stats(path: Path, *, stale_before: str, scope: Scope) -> dict[str, Any]:
+    conn = open_connection(path)
+    try:
+        conn.execute("BEGIN")
+        stats = project_stats(conn, stale_before=stale_before)
+        findings = integrity_findings(conn, scope=scope, stale_before=stale_before)
+        conn.execute("COMMIT")
+    finally:
+        conn.close()
+    return {"db_path": str(path), **stats, "findings": findings}
+
+
+def _local_stats(*, stale_before: str) -> dict[str, Any] | None:
+    """The local project's own stats, or None if no project resolves from cwd.
+
+    Checking existence rather than always resolving is what lets `doctor`
+    run from any directory (§3.3, mirroring the global side below) instead
+    of hard-failing outside a project.
+    """
+    if not project_exists():
+        return None
+    with corvee_context(write=False) as ctx:
+        return _db_stats(ctx.db_path, stale_before=stale_before, scope="local")
+
+
+def _global_stats(*, stale_before: str) -> dict[str, Any] | None:
+    """The global database's own stats, or None if it does not exist yet.
+
+    Checking existence rather than always opening it is what keeps `doctor`
+    read-only for a project that has never used `--global`: nothing about
+    running this command creates the file.
+    """
+    path = global_db_path()
+    if not path.is_file():
+        return None
+    return _db_stats(path, stale_before=stale_before, scope="global")
+
+
+@click.command(epilog=EPILOG)
+@click.option("--stale", "-i", "stale_duration", default=DEFAULT_STALE_DURATION, show_default=True)
+@click.option("--json", "-j", "as_json", is_flag=True)
+def doctor(stale_duration: str, as_json: bool) -> None:
+    """Project health: task/fact counts, staleness, and schema version."""
+    cutoff = datetime.now(UTC) - parse_duration(stale_duration)
+    stale_before = timestamp(cutoff)
+    payload = {
+        "schema_version": CURRENT_SCHEMA_VERSION,
+        "local": _local_stats(stale_before=stale_before),
+        "global": _global_stats(stale_before=stale_before),
+    }
+    if as_json:
+        click.echo(json.dumps(payload))
+    else:
+        click.echo(_render_text(payload))

corvee/cli/commands/explain.py

@@ -0,0 +1,122 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import click
+
+EPILOG = """\
+\b
+Examples:
+Print the cheat sheet:
+  corvee explain
+Page through it if the terminal is too short:
+  corvee explain | less
+Save it as a file an agent can be pointed at directly:
+  corvee explain > AGENTS_corvee_cheatsheet.txt
+"""
+
+EXPLAIN_TEXT = """\
+corvee: a local, multi-agent-aware CLI issue tracker, plus a standalone
+store of checked-true facts. Multiple agents and humans can work the same
+backlog concurrently — claims prevent two actors from editing the same task
+at once.
+
+Operating rule, not an example to adapt: track work as you go, never after
+the fact. This applies to any nontrivial piece of work, not just code — a
+research task, a writeup, a document review, anything worth resuming.
+Before starting, `task add` it (with --description) and `task claim` it —
+filing a task once the work is already done gives a resuming session
+nothing to resume from, which is the one thing this tool exists to
+prevent. The same applies to facts: `fact add`/`fact verify` a claim the
+moment you establish it (from research, a source, a computed result — not
+only code), not batched in at the end of a session.
+
+TASKS
+
+One task per independently-resolvable item, not one umbrella task: a
+batch of distinct, separately-finishable pieces (a batch of FIXMEs, a
+list of bugs) gets one `task add` each. Bundling them loses corvee's
+resumability and independent-completion value — no way to tell which
+piece is actually done, no way to split the batch across agents.
+
+Resuming beats starting something new:
+  corvee brief --json                           # mine + ready + stale in one call
+  corvee task mine --json                       # what am I already working on?
+
+Check before you file, and see what's startable right now:
+  corvee task ready --json                      # unclaimed, unblocked, open tasks
+  corvee task search "auth token" --json        # does a task for this exist already?
+  corvee task list --fields id,title --json     # cheap session-start overview
+
+File it, claim it, then work it — in that order, every time. Don't skip
+steps: stay in_progress while working, comment before marking done — a
+task with no claim and no comment leaves nothing for a resuming session
+(yours or another agent's) to pick up from.
+  corvee task add "Fix the flaky auth test" --description "..." --json
+  corvee task claim TASK-14 --json
+  corvee task update TASK-14 --state in_progress --json
+  corvee task comment TASK-14 "found the root cause, writing a fix" --json
+  corvee task update TASK-14 --state done --json
+  corvee task show TASK-14 --json             # full detail, incl. the timeline
+
+Don't leave every task at the --type/--priority defaults (task/medium)
+when a more specific one is true: a bug found along the way is
+--type bug, something genuinely blocking is --priority high or
+critical, and a task that can't start until another finishes is a
+relation, not just a sentence in the description:
+  corvee task link TASK-15 TASK-14 --relation blocks --json
+
+Claims: `corvee task claim <id>` fails if another actor holds the task,
+unless --force. Re-running `corvee task claim <id>` on a task already held
+refreshes it — the heartbeat. A claim goes stale after 4h of silence and can
+then be taken by another agent (see `corvee task list --stale`). See who
+currently holds what, and since when:
+  corvee task claims --json
+
+Routing work to a specific actor without claiming it on their behalf:
+  corvee task assign TASK-14 --to agent:claude --json
+`task mine` then shows it for agent:claude the moment it's unclaimed.
+
+FACTS
+
+Facts are a separate, standalone store for checked-true claims with proof —
+not tasks, and not linked to them by the schema. Connect the two by
+convention if useful, e.g. mentioning a fact id in a task comment:
+  corvee fact add "requests is Apache-2.0 licensed" --json --proof \\
+    "pip download requests --no-deps -d /tmp && unzip -q /tmp/requests-*.whl -d /tmp/requests-whl \\
+    && grep -i '^License:' /tmp/requests-whl/*/METADATA"
+  corvee fact search "license" --json           # does a fact for this exist already?
+
+GENERAL
+
+Not project-specific? --global on task/fact add files into one database
+shared across every project on the machine instead of this one. Every
+other command reads local vs. global from the id itself (TASK-GLOBAL-<n>),
+so --global is only ever needed on add:
+  corvee task add "renew the CA cert" --description "expires yearly" --global --json
+  corvee task list --scope local --json         # this project's backlog only, not merged
+
+Identity: corvee --actor agent:claude --session-id <token> <command> on
+every call — passing the flags keeps the command line a plain `corvee ...`
+invocation a permission allowlist can match, instead of an `export`
+beforehand, which usually needs broader permissions. No --actor given
+defaults to human:$USER. Set it explicitly whenever more than one session
+might touch this backlog at once: two unconfigured sessions on the same
+machine share that identity, and claims stop protecting anything between
+them. corvee doctor flags a claimed task with recent activity from more
+than one session under one actor string, which is what that collision
+looks like after the fact.
+
+Always pass --json. Success is a JSON array of objects on stdout; failure is
+an object on stderr: {"error": {"code": ..., "message": ...}}.
+
+Full flag reference for any command: corvee <command> --help
+"""
+
+
+@click.command(epilog=EPILOG)
+def explain() -> None:
+    """Print a compact, agent-oriented cheat sheet."""
+    click.echo(EXPLAIN_TEXT)

corvee/cli/commands/export.py

@@ -0,0 +1,42 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import json
+from pathlib import Path
+from typing import cast
+
+import click
+
+from corvee.cli.context import corvee_context
+from corvee.constants import SCOPES, Scope
+from corvee.db.export_import import export_project
+
+EPILOG = """\
+\b
+Examples:
+Dump the whole project to stdout:
+  corvee export
+Write the dump to a file instead:
+  corvee export --output backup.json
+Name the backup file after today's date:
+  corvee export --output "$(date +%F)-corvee-backup.json"
+Back up the machine-wide global database instead:
+  corvee export --scope global --output global-backup.json
+"""
+
+
+@click.command(epilog=EPILOG)
+@click.option("--output", "-o", "output_path", type=click.Path())
+@click.option("--scope", "-s", "scope", type=click.Choice(SCOPES), default="local")
+def export(output_path: str | None, scope: str) -> None:
+    """Dump the whole project (or --scope global) as JSON."""
+    with corvee_context(write=False, scope=cast(Scope, scope)) as ctx:
+        data = export_project(ctx.conn)
+    text = json.dumps(data)
+    if output_path:
+        Path(output_path).write_text(text)
+    else:
+        click.echo(text)

corvee/cli/commands/fact/__init__.py

@@ -0,0 +1,45 @@
+#
+# Copyright (C) 2026 Benjamin Thomas Schwertfeger
+# SPDX-License-Identifier: Apache-2.0
+# https://github.com/btschwertfeger
+#
+
+import click
+
+from corvee.cli.commands.fact.add import add
+from corvee.cli.commands.fact.delete import delete
+from corvee.cli.commands.fact.list_ import list_command
+from corvee.cli.commands.fact.retract import retract
+from corvee.cli.commands.fact.revise import revise
+from corvee.cli.commands.fact.search import search
+from corvee.cli.commands.fact.show import show
+from corvee.cli.commands.fact.unverify import unverify
+from corvee.cli.commands.fact.verify import verify
+from corvee.cli.params import AliasGroup
+
+
+@click.group(name="fact", cls=AliasGroup, hidden_aliases={"ls"})
+def fact_group() -> None:
+    """Standalone, checked-true claims, kept separate from tasks.
+
+    \b
+    Lifecycle: a fact starts unverified. `verify` marks it verified with
+    proof and a timestamp; `unverify` moves it back. `revise` changes the
+    claim text and, if it was verified, resets it to unverified, since the
+    old proof said nothing about the new text. `retract` withdraws a fact
+    that should not have existed, dropping it out of the default `list`;
+    `verify`, `unverify`, and `revise` all still work on a retracted fact
+    and bring it back into the normal flow.
+    """
+
+
+fact_group.add_command(add)
+fact_group.add_command(list_command)
+fact_group.add_command(list_command, name="ls")
+fact_group.add_command(search)
+fact_group.add_command(show)
+fact_group.add_command(verify)
+fact_group.add_command(unverify)
+fact_group.add_command(revise)
+fact_group.add_command(retract)
+fact_group.add_command(delete)