833 lines
48 KiB
Python
833 lines
48 KiB
Python
"""harbor: messages, threads, acknowledgements, claims, review items and stop flags for a team of AI agents.
|
|
|
|
Project: --project <name or file.toml>, $HARBOR_PROJECT, or the nearest .harbor.toml above the working directory.
|
|
Identity: --as <Agent>, $HARBOR_AGENT, or the project's [identities] entry for the working directory.
|
|
The human speaks from the chat page only, never from this command line.
|
|
|
|
Start of every session: harbor brief
|
|
Take work: harbor next (the best task you may do; claims its scope)
|
|
While working: harbor doing "drafting 0x529350" (one line the whole team sees)
|
|
Waiting for answers: harbor wait --timeout 600 (returns as soon as a message arrives)
|
|
Before the session ends: harbor handoff "done X; Y in flight; next Z"
|
|
Tasks: harbor task add "Name 0x445310" --scope fn:0x445310 --priority high --after 3
|
|
harbor tasks harbor task done 5 --note "..." harbor task block 5 --note "needs 0x4E2680"
|
|
Messages:
|
|
harbor send Claude "text" --thread fn:0x529350 --subject "AudioManagerTick" --kind question
|
|
harbor reply 123 "text" harbor inbox harbor ack 123 --note "fixed in a2d7525"
|
|
harbor thread fn:0x529350 harbor search "AudioManagerTick" harbor threads
|
|
Claims: harbor claim fn:0x529350 --note "writing the body" harbor release --scope fn:0x529350
|
|
Review queue: harbor submit "AudioManagerTick readable" --scope fn:0x529350 --commit a2d7525
|
|
harbor review 7 approved --note "..." harbor land 7 --commit b4b44f0 harbor queue
|
|
Overview: harbor status harbor digest --since 8h harbor attention
|
|
Stop: harbor stop <yourself> (a coordinator may stop anyone; only the human resumes, from the page)
|
|
Long bodies: --file path (or --file - for stdin); attachments: --attach path (repeatable).
|
|
"""
|
|
import argparse
|
|
import json
|
|
import os
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
from . import projects
|
|
from .core import CLAIM_KINDS, IMPORTANCE, ITEM_STATES, KINDS, OPEN_ITEM_STATES, TASK_STATES, Harbor, HarborError
|
|
|
|
|
|
def fmt_message(m):
|
|
tags = [f"thread {m['thread_id']} {m.get('topic', '')}".strip()]
|
|
if m["kind"] != "note":
|
|
tags.append(m["kind"])
|
|
if m["importance"] != "normal":
|
|
tags.append(m["importance"])
|
|
if m.get("ack_required"):
|
|
tags.append("ack")
|
|
if m.get("reply_to"):
|
|
tags.append(f"re #{m['reply_to']}")
|
|
if m.get("corrects"):
|
|
tags.append(f"corrects #{m['corrects']}")
|
|
if m.get("due_at"):
|
|
tags.append(f"due {m['due_at']}")
|
|
to = ",".join(m["recipients"])
|
|
head = f"#{m['id']} {m['created_at'].replace('T', ' ')[:16]}Z {m['sender']} → {to} [{' · '.join(tags)}]"
|
|
body = "\n".join(" " + line for line in m["body"].split("\n"))
|
|
files = m.get("refs", {}).get("attachments")
|
|
return head + "\n" + body + (f"\n attachments: {', '.join(files)}" if files else "")
|
|
|
|
|
|
def fmt_task(task):
|
|
who = task["assignee"] or "unassigned"
|
|
extra = []
|
|
if task["scope"]:
|
|
extra.append(task["scope"])
|
|
if task["waiting_on"]:
|
|
extra.append("after " + ",".join(f"#{d}" for d in task["waiting_on"]))
|
|
if task["due_at"]:
|
|
extra.append(f"due {task['due_at']}")
|
|
if task["item_id"]:
|
|
extra.append(f"item #{task['item_id']}")
|
|
if task["state"] == "blocked":
|
|
extra.append(f"blocked: {task['block_reason']}")
|
|
return (f"#{task['id']:>4} {task['state']:<11} {task['priority_name']:<6} {who:<9} {task['title']}"
|
|
+ (f" ({'; '.join(extra)})" if extra else ""))
|
|
|
|
|
|
def body_from(args):
|
|
if getattr(args, "file", None):
|
|
return sys.stdin.read() if args.file == "-" else Path(args.file).read_text(encoding="utf-8")
|
|
return " ".join(args.text)
|
|
|
|
|
|
def refs_from(pairs):
|
|
refs = {}
|
|
for pair in pairs or []:
|
|
if "=" not in pair:
|
|
raise HarborError(f"--ref {pair!r}: use key=value, e.g. commit=b4b44f0 or fn=0x529350")
|
|
key, value = pair.split("=", 1)
|
|
refs[key.strip()] = value.strip()
|
|
return refs
|
|
|
|
|
|
def recipients(text):
|
|
return None if not text else ("All" if text == "All" else [t.strip() for t in text.split(",") if t.strip()])
|
|
|
|
|
|
def build_parser():
|
|
parser = argparse.ArgumentParser(prog="harbor", description=__doc__.split("\n")[0],
|
|
formatter_class=argparse.RawDescriptionHelpFormatter, epilog=__doc__)
|
|
parser.add_argument("--as", dest="agent", default=None)
|
|
parser.add_argument("--project", default=None, help="project name or path to its .toml")
|
|
parser.add_argument("--json", action="store_true", help="machine-readable output")
|
|
sub = parser.add_subparsers(dest="cmd", required=True)
|
|
|
|
p = sub.add_parser("brief", help="what you need to know at the start of a session")
|
|
p.add_argument("--mark-read", action="store_true")
|
|
p = sub.add_parser("inbox", help="unread messages (urgent first); marks them read")
|
|
p.add_argument("--all", action="store_true", help="recent messages, read or not")
|
|
p.add_argument("--peek", action="store_true", help="do not mark read")
|
|
p.add_argument("--limit", type=int, default=30)
|
|
p = sub.add_parser("wait", help="block until a message for you arrives or a stop applies (then print it)")
|
|
p.add_argument("--timeout", type=float, default=300, help="seconds (max 3600)")
|
|
p.add_argument("--peek", action="store_true")
|
|
for name in ("send", "reply"):
|
|
p = sub.add_parser(name)
|
|
if name == "send":
|
|
p.add_argument("to", help="Agent, Agent,Agent or All")
|
|
p.add_argument("--subject")
|
|
p.add_argument("--thread", help="thread id or topic, e.g. fn:0x529350, commit:b4b44f0, general")
|
|
else:
|
|
p.add_argument("message_id", type=int)
|
|
p.add_argument("--to", help="override recipients (Agent,Agent or All)")
|
|
p.add_argument("text", nargs="*")
|
|
p.add_argument("--file")
|
|
p.add_argument("--attach", action="append", help="copy a file into Harbor and link it (repeatable)")
|
|
p.add_argument("--kind", choices=KINDS, default="answer" if name == "reply" else "note")
|
|
p.add_argument("--importance", choices=IMPORTANCE, default="normal")
|
|
p.add_argument("--ack", action="store_true", help="ask the recipients to acknowledge")
|
|
p.add_argument("--ref", action="append", help="key=value (commit=..., fn=0x..., file=...)")
|
|
p.add_argument("--corrects", type=int, help="id of your earlier message this corrects")
|
|
p.add_argument("--due", help="answer needed within 30m / 2h / 1d, or by an ISO time")
|
|
p = sub.add_parser("ack", help="acknowledge messages addressed to you")
|
|
p.add_argument("ids", type=int, nargs="+")
|
|
p.add_argument("--note")
|
|
p = sub.add_parser("doing", help="set the one line the team sees about what you are doing (no text clears it)")
|
|
p.add_argument("text", nargs="*")
|
|
p = sub.add_parser("thread", help="show a whole thread")
|
|
p.add_argument("thread")
|
|
for name in ("close", "reopen"):
|
|
p = sub.add_parser(name, help=f"{name} a thread")
|
|
p.add_argument("thread")
|
|
p = sub.add_parser("threads", help="recent threads")
|
|
p.add_argument("--limit", type=int, default=25)
|
|
p.add_argument("--archive", action="store_true", help="include imported chat archives")
|
|
p.add_argument("--open", action="store_true", help="hide closed threads")
|
|
p = sub.add_parser("search", help="full-text search over every message")
|
|
p.add_argument("query", nargs="+")
|
|
p.add_argument("--limit", type=int, default=15)
|
|
p = sub.add_parser("tail", help="the most recent messages")
|
|
p.add_argument("count", type=int, nargs="?", default=20)
|
|
p = sub.add_parser("claim", help="claim a function, range, name, task or file")
|
|
p.add_argument("scope", help="fn:0xADDR, range:0xLO-0xHI, name:Symbol, task:text, file:path")
|
|
p.add_argument("--kind", choices=sorted(CLAIM_KINDS), default="draft")
|
|
p.add_argument("--ttl", type=float, help="hours (default by kind)")
|
|
p.add_argument("--note")
|
|
p.add_argument("--for", dest="for_agent", help="coordinator only: record the claim for another agent")
|
|
p.add_argument("--override", action="store_true", help="coordinator only")
|
|
p = sub.add_parser("release", help="release a claim")
|
|
p.add_argument("claim_id", type=int, nargs="?")
|
|
p.add_argument("--scope")
|
|
p = sub.add_parser("claims", help="active claims")
|
|
p.add_argument("--agent", dest="filter_agent")
|
|
p.add_argument("--kind")
|
|
p = sub.add_parser("submit", help="put a commit in the review queue")
|
|
p.add_argument("title")
|
|
p.add_argument("--scope")
|
|
p.add_argument("--commit")
|
|
p.add_argument("--branch")
|
|
p.add_argument("--note")
|
|
p.add_argument("--reviewer", action="append")
|
|
p.add_argument("--task", type=int, help="the task this work completes (landing closes it)")
|
|
p = sub.add_parser("review", help="move a review item")
|
|
p.add_argument("item", type=int)
|
|
p.add_argument("state", choices=[s for s in ITEM_STATES if s not in ("landed", "withdrawn")])
|
|
p.add_argument("--note")
|
|
p.add_argument("--commit")
|
|
p = sub.add_parser("withdraw", help="author withdraws an item")
|
|
p.add_argument("item", type=int)
|
|
p.add_argument("--note")
|
|
p = sub.add_parser("land", help="coordinator: the items are on main (several items: one message per author)")
|
|
p.add_argument("item", type=int, nargs="+")
|
|
p.add_argument("--commit", required=True)
|
|
p.add_argument("--note")
|
|
p = sub.add_parser("item", help="one review item with its history")
|
|
p.add_argument("item", type=int)
|
|
p = sub.add_parser("queue", help="open review items")
|
|
p.add_argument("--all", action="store_true")
|
|
sub.add_parser("status", help="stop flags, presence, unread counts and the queue at a glance")
|
|
p = sub.add_parser("tasks", help="the task list (open work by default)")
|
|
p.add_argument("--all", action="store_true", help="include done and cancelled")
|
|
p.add_argument("--mine", action="store_true")
|
|
p.add_argument("--agent", dest="filter_agent")
|
|
p = sub.add_parser("task", help="add, show or move a task")
|
|
p.add_argument("action", choices=("add", "show", "take", "done", "block", "release", "cancel", "reopen", "bulk",
|
|
"template"))
|
|
p.add_argument("args", nargs="*", help="add: the title; template: name and scope; bulk: none (--file); "
|
|
"others: the task id")
|
|
p.add_argument("--template", help="bulk: run this template for every line")
|
|
p.add_argument("--body")
|
|
p.add_argument("--file")
|
|
p.add_argument("--scope")
|
|
p.add_argument("--for", dest="for_agent", help="assign to an agent (coordinators; or yourself)")
|
|
p.add_argument("--priority", default="normal", choices=("urgent", "high", "normal", "low"))
|
|
p.add_argument("--after", type=int, action="append", help="a task that must be done first (repeatable)")
|
|
p.add_argument("--due", help="30m / 2h / 1d or an ISO time")
|
|
p.add_argument("--note")
|
|
p = sub.add_parser("next", help="take the best task you may do now (claims its scope)")
|
|
p.add_argument("--peek", action="store_true", help="show it without taking it")
|
|
p = sub.add_parser("handoff", help="record where you left off; shown at the start of your next session")
|
|
p.add_argument("text", nargs="*")
|
|
p.add_argument("--file")
|
|
p = sub.add_parser("handoffs", help="recent handoffs")
|
|
p.add_argument("--agent", dest="filter_agent")
|
|
p.add_argument("--limit", type=int, default=5)
|
|
for name in ("pin", "unpin"):
|
|
p = sub.add_parser(name, help=f"{name} a message for the whole team")
|
|
p.add_argument("message_id", type=int)
|
|
if name == "pin":
|
|
p.add_argument("--note", help="a one-line label")
|
|
sub.add_parser("pins", help="pinned messages")
|
|
sub.add_parser("decisions", help="recent messages of kind decision")
|
|
p = sub.add_parser("prompt", help="a restart prompt for an agent (paste it into a fresh session)")
|
|
p.add_argument("agent_name")
|
|
sub.add_parser("doctor", help="check the project, the database, the server and every host integration")
|
|
p = sub.add_parser("ask", help="ask the human (or an agent) a question with answer options")
|
|
p.add_argument("question", nargs="+")
|
|
p.add_argument("--options", help='answer buttons, separated by | e.g. "Yes|No|Later"')
|
|
p.add_argument("--to", help="who answers (default: the human)")
|
|
p.add_argument("--due", help="30m / 2h / an ISO time")
|
|
p.add_argument("--fallback", help="a coordinator who may answer while the human is away")
|
|
p.add_argument("--thread")
|
|
p = sub.add_parser("answer", help="answer a question addressed to you")
|
|
p.add_argument("question_id", type=int)
|
|
p.add_argument("text", nargs="+")
|
|
p = sub.add_parser("questions", help="open questions (to you and from you)")
|
|
p.add_argument("--all", action="store_true", help="include answered ones")
|
|
p = sub.add_parser("note", help="add to the team's memory about a scope (fn:0x..., file:..., name:...)")
|
|
p.add_argument("scope")
|
|
p.add_argument("text", nargs="+")
|
|
p.add_argument("--replaces", type=int, help="the id of an older note this one corrects")
|
|
p = sub.add_parser("notes", help="notes, all or for one scope")
|
|
p.add_argument("scope", nargs="?")
|
|
p = sub.add_parser("context", help="everything the team knows about a scope")
|
|
p.add_argument("scope")
|
|
p = sub.add_parser("metric", help="report a number the board charts (e.g. readable 779)")
|
|
p.add_argument("name")
|
|
p.add_argument("value")
|
|
p.add_argument("--note")
|
|
sub.add_parser("metrics", help="the latest value of every metric")
|
|
p = sub.add_parser("pulse", help="who was active when (tool calls and messages per hour)")
|
|
p.add_argument("--hours", type=int, default=12)
|
|
p = sub.add_parser("wins", help="landed review items")
|
|
p.add_argument("--since", default="24h")
|
|
sub.add_parser("git", help="each agent's branch, last commit, uncommitted files and unsubmitted commits")
|
|
p = sub.add_parser("summarize", help="pin a short summary to a thread (shown on top of it and in context)")
|
|
p.add_argument("thread")
|
|
p.add_argument("text", nargs="*")
|
|
p.add_argument("--file")
|
|
p = sub.add_parser("who", help="who has worked on a scope (notes, reviews, claims, messages)")
|
|
p.add_argument("scope")
|
|
p = sub.add_parser("re", help="reverse-engineering lookups from the project's image and annotations")
|
|
p.add_argument("action", choices=["disasm", "xrefs", "bytes", "lookup", "ghidra", "ghidra-tools", "debugger-tools", "match", "similar", "struct-audit", "behaviour"])
|
|
p.add_argument("target", nargs="?", default="", help="an address (0x4AD850) or a name; for ghidra, the tool")
|
|
p.add_argument("arguments", nargs="?", default="{}", help="ghidra: the tool's arguments as JSON")
|
|
p.add_argument("--decomp", help="match: the checkout or worktree to compile from")
|
|
p.add_argument("--max-bytes", type=int, dest="max_bytes")
|
|
p.add_argument("--count", type=int, default=16)
|
|
p.add_argument("--as", dest="as_type", default="hex", choices=["hex", "int32", "uint32", "float", "double", "string"])
|
|
p = sub.add_parser("logbook", help="the project Logbook: add a log entry, set statistics, the chart or a milestone")
|
|
p.add_argument("action", choices=["add", "stats", "map", "milestone", "show", "import", "refresh"])
|
|
p.add_argument("--title")
|
|
p.add_argument("--kind", default="note")
|
|
p.add_argument("--detail", help="the entry text (or --file)")
|
|
p.add_argument("--file", help="a text file (add) or a JSON file (stats, map, milestone) or an export folder (import)")
|
|
p.add_argument("--no-history", action="store_true", help="stats: do not add a trend point")
|
|
p = sub.add_parser("next-functions", help="functions in your bands to decompile next, easiest first")
|
|
p.add_argument("-n", type=int, default=10)
|
|
p = sub.add_parser("defer", help="set a function aside with a reason and evidence")
|
|
p.add_argument("address")
|
|
p.add_argument("reason")
|
|
p.add_argument("evidence")
|
|
sub.add_parser("progress", help="functions and bytes per tier: exact, verified, readable, deferred, raw")
|
|
p = sub.add_parser("feed", help="the latest tool calls of the team (or one agent), from the hooks")
|
|
p.add_argument("--agent", dest="filter_agent")
|
|
p.add_argument("--limit", type=int, default=30)
|
|
sub.add_parser("templates", help="task templates defined in the project file")
|
|
p = sub.add_parser("export", help="a thread as Markdown")
|
|
p.add_argument("thread")
|
|
p.add_argument("--out", help="write to this file instead of printing")
|
|
p = sub.add_parser("digest", help="what happened in a window (default the last 8 hours)")
|
|
p.add_argument("--since", default="8h", help="8h, 90m, 2d or an ISO time")
|
|
sub.add_parser("attention", help="overdue acknowledgements, stale review items, quiet agents")
|
|
for name in ("stop", "resume"):
|
|
p = sub.add_parser(name, help=f"{name} everyone or one agent")
|
|
p.add_argument("target", help="all or an agent name")
|
|
p.add_argument("--relay", type=int, help="id of the human's chat-page message that asked for this")
|
|
p.add_argument("--reason")
|
|
p = sub.add_parser("pending-acks", help="messages still waiting for acknowledgement")
|
|
p.add_argument("--overdue", type=int, default=0, help="minutes")
|
|
p = sub.add_parser("import-legacy", help="import a plain `[time] From → To: text` chat history (idempotent)")
|
|
p.add_argument("path")
|
|
p = sub.add_parser("backup", help="snapshot the database into the project's backups folder")
|
|
p.add_argument("--keep", type=int, default=14)
|
|
sub.add_parser("whoami", help="which project and identity this directory resolves to")
|
|
sub.add_parser("projects", help="registered projects")
|
|
p = sub.add_parser("init", help="create a project")
|
|
p.add_argument("name")
|
|
p.add_argument("--title")
|
|
p.add_argument("--agent", dest="roster", action="append", required=True,
|
|
help="Name or Name:role (repeat for each agent; the human is added automatically)")
|
|
p.add_argument("--human", default="User")
|
|
p.add_argument("--coordinator", action="append", default=[])
|
|
p.add_argument("--database")
|
|
p.add_argument("--mirror")
|
|
p.add_argument("--marker", help="also write a .harbor.toml in this folder pointing at the project")
|
|
p = sub.add_parser("hook", help="entry point for an agent host's hooks (see harbor.hooks)")
|
|
p.add_argument("event")
|
|
p.add_argument("--host", default="generic")
|
|
p = sub.add_parser("install", help="connect an agent host (codex, opencode, deepseek, kimi, claude) to Harbor")
|
|
p.add_argument("host", choices=("codex", "opencode", "deepseek", "kimi", "claude"))
|
|
p.add_argument("--agent", dest="host_agent",
|
|
help="the host's Harbor identity (default: Codex, OpenCode, DeepSeek, Kimi, Claude)")
|
|
p.add_argument("--bind", action="store_true", help="bind the host to --project instead of the working folder")
|
|
p.add_argument("--dry-run", action="store_true", help="show what would change")
|
|
p.add_argument("--uninstall", action="store_true", help="remove Harbor's entries again")
|
|
p.add_argument("--python", help='interpreter command for hosts to run, e.g. "py -3.12" (default: detected)')
|
|
p.add_argument("--no-register", action="store_true", help="kimi: build and validate the plugin only")
|
|
p = sub.add_parser("serve", help="run the chat page and board")
|
|
p.add_argument("--port", type=int, default=8766)
|
|
sub.add_parser("mcp", help="run the MCP server on stdio (identity from --as or $HARBOR_AGENT)")
|
|
return parser
|
|
|
|
|
|
def main(argv=None):
|
|
if hasattr(sys.stdout, "reconfigure"):
|
|
sys.stdout.reconfigure(encoding="utf-8")
|
|
args = build_parser().parse_args(argv)
|
|
cmd = args.cmd
|
|
|
|
if cmd == "projects":
|
|
home = projects.harbor_home()
|
|
names = projects.list_names(home)
|
|
marker = projects.find_marker()
|
|
default = projects.default_name(home)
|
|
rows = [{"name": n, "default": n == default} for n in names]
|
|
text = f"Harbor home: {home}\n" + ("\n".join(f" {n}{' (default)' if n == default else ''}" for n in names)
|
|
or " no registered projects")
|
|
if marker:
|
|
text += f"\nThis directory belongs to: {marker}"
|
|
print(json.dumps(rows) if args.json else text)
|
|
return
|
|
if cmd == "init":
|
|
home = projects.harbor_home()
|
|
agents = []
|
|
for spec in args.roster:
|
|
name, _, role = spec.partition(":")
|
|
agents.append({"name": name.strip(), "role": role.strip()})
|
|
path = projects.write_project(home / "projects" / f"{args.name}.toml", args.name, args.title or args.name,
|
|
agents, human=args.human, coordinators=args.coordinator,
|
|
database=args.database, mirror=args.mirror)
|
|
print(f"created {path}")
|
|
if not projects.default_name(home):
|
|
(home / "config.toml").write_text(f'default_project = "{args.name}"\n', encoding="utf-8")
|
|
print(f"{args.name} is the default project")
|
|
if args.marker:
|
|
marker = Path(args.marker) / projects.MARKER
|
|
if marker.exists():
|
|
raise HarborError(f"{marker} already exists")
|
|
marker.write_text(f'project = "{args.name}"\n', encoding="utf-8")
|
|
print(f"wrote {marker}")
|
|
return
|
|
|
|
if cmd == "install":
|
|
from . import install
|
|
bound = args.project if (args.bind or args.host == "kimi") else None
|
|
try:
|
|
report = install.install(args.host, agent=args.host_agent, project=bound, dry_run=args.dry_run,
|
|
remove=args.uninstall, python=args.python, register=not args.no_register)
|
|
except install.InstallError as error:
|
|
raise HarborError(str(error))
|
|
print(("Dry run - nothing written.\n" if args.dry_run else "") + "\n".join(report))
|
|
return
|
|
if cmd == "hook": # resolves the project from the host's payload, never raises
|
|
from . import hooks
|
|
sys.exit(hooks.run(args.event, args.project, args.agent, host=args.host))
|
|
project = projects.resolve(args.project)
|
|
if cmd == "serve":
|
|
from . import server
|
|
server.main(["--port", str(args.port)] + (["--project", args.project] if args.project else []))
|
|
return
|
|
if cmd == "mcp":
|
|
if args.agent:
|
|
os.environ["HARBOR_AGENT"] = args.agent
|
|
from . import mcp_server
|
|
mcp_server.main(project)
|
|
return
|
|
|
|
harbor = Harbor(project)
|
|
source = "--as" if args.agent else None
|
|
agent = args.agent or os.environ.get("HARBOR_AGENT")
|
|
if agent and not source:
|
|
source = "HARBOR_AGENT"
|
|
if not agent:
|
|
agent = project.identity_for(os.getcwd())
|
|
source = "working directory" if agent else None
|
|
else:
|
|
# a second session of the same app (Codex2 in the Codex app) copies the app's shared `--as Codex`
|
|
# instructions; its working folder says who it is
|
|
session = project.session_identity(agent, os.getcwd())
|
|
if session != agent:
|
|
agent, source = session, f"working directory (same app as {agent})"
|
|
|
|
recorded = []
|
|
|
|
def who():
|
|
if not agent:
|
|
raise HarborError("say who you are: --as <Agent>, set HARBOR_AGENT, or work inside a directory listed "
|
|
"under [identities] in the project file")
|
|
if agent == project.human:
|
|
raise HarborError(f"{project.human} speaks from the chat page, not the command line")
|
|
if agent not in project.ai_names:
|
|
raise HarborError(f"unknown agent {agent!r}; this project has {', '.join(project.ai_names)}")
|
|
if not recorded and cmd not in ("whoami", "prompt"):
|
|
recorded.append(True)
|
|
harbor.activity(agent, f"harbor {cmd}", os.environ.get("HARBOR_HOST", ""), channel="cli")
|
|
return agent
|
|
|
|
def out(value, text):
|
|
print(json.dumps(value, ensure_ascii=False, indent=1, default=str) if args.json else text)
|
|
|
|
if cmd == "whoami":
|
|
out({"project": project.name, "source": str(project.source), "agent": agent, "identity_from": source},
|
|
f"project {project.name} ({project.title}) from {project.source}\n"
|
|
f"agent {agent or '(none)'}" + (f" from {source}" if source else ""))
|
|
elif cmd == "brief":
|
|
text = harbor.brief(who(), mark_read=args.mark_read)
|
|
out({"brief": text}, text)
|
|
elif cmd == "inbox":
|
|
rows = harbor.inbox(who(), unread_only=not args.all, limit=args.limit, mark_read=not args.peek)
|
|
out(rows, "\n\n".join(fmt_message(m) for m in rows) or "No unread messages.")
|
|
elif cmd == "wait":
|
|
r = harbor.wait(who(), timeout=args.timeout, mark_read=not args.peek)
|
|
if r["stopped"]:
|
|
text = "STOP in force (" + ", ".join(r["stopped"]) + "): do not start or continue work."
|
|
elif r["timed_out"]:
|
|
text = "No new messages."
|
|
else:
|
|
text = "\n\n".join(fmt_message(m) for m in r["messages"])
|
|
out(r, text)
|
|
elif cmd in ("send", "reply"):
|
|
text = body_from(args)
|
|
if cmd == "send":
|
|
r = harbor.send(who(), recipients(args.to), text, subject=args.subject, thread=args.thread, kind=args.kind,
|
|
importance=args.importance, ack_required=args.ack, refs=refs_from(args.ref),
|
|
attachments=args.attach, corrects=args.corrects, due=args.due)
|
|
else:
|
|
r = harbor.send(who(), recipients(args.to), text, reply_to=args.message_id, kind=args.kind,
|
|
importance=args.importance, ack_required=args.ack, refs=refs_from(args.ref),
|
|
attachments=args.attach, corrects=args.corrects, due=args.due)
|
|
lines = [f"sent #{r['id']} in thread {r['thread_id']} ({r['topic']}) to {', '.join(r['targets'])}"]
|
|
lines += [f"warning: {w}" for w in r["warnings"]]
|
|
out(r, "\n".join(lines))
|
|
elif cmd == "ack":
|
|
out(harbor.ack(who(), args.ids, args.note), "acknowledged " + ", ".join(f"#{i}" for i in args.ids))
|
|
elif cmd == "doing":
|
|
r = harbor.doing(who(), " ".join(args.text))
|
|
out(r, f"{r['agent']}: {r['doing'] or '(cleared)'}")
|
|
elif cmd == "thread":
|
|
thread, messages = harbor.thread(args.thread)
|
|
out({"thread": thread, "messages": messages},
|
|
f"Thread {thread['id']} {thread['topic']}: {thread['subject']} ({thread['state']})\n\n"
|
|
+ "\n\n".join(fmt_message(m) for m in messages))
|
|
elif cmd in ("close", "reopen"):
|
|
t = harbor.set_thread_state(who(), args.thread, "closed" if cmd == "close" else "open")
|
|
out(t, f"thread {t['id']} {t['topic']} is {t['state']}")
|
|
elif cmd == "threads":
|
|
rows = harbor.threads(limit=args.limit, agent=agent if agent and agent != project.human else None,
|
|
include_legacy=args.archive, include_closed=not args.open)
|
|
out(rows, "\n".join(f"{r['id']:>5} {r['updated_at'][:16]}Z {r['messages']:>4} msgs"
|
|
+ (f" {r['unread']} unread" if r.get('unread') else "")
|
|
+ (f" [{r['state']}]" if r['state'] != 'open' else "")
|
|
+ f" {r['topic']}: {r['subject']}" for r in rows) or "No threads.")
|
|
elif cmd == "search":
|
|
rows = harbor.search(" ".join(args.query), limit=args.limit)
|
|
out(rows, "\n\n".join(fmt_message(m) for m in rows) or "No matches.")
|
|
elif cmd == "tail":
|
|
rows = harbor.recent(args.count)
|
|
out(rows, "\n\n".join(fmt_message(m) for m in rows))
|
|
elif cmd == "claim":
|
|
r = harbor.claim(who(), args.scope, kind=args.kind, ttl_hours=args.ttl, note=args.note,
|
|
override=args.override, on_behalf_of=args.for_agent)
|
|
out(r, f"{'renewed' if r['renewed'] else 'claimed'} #{r['id']} {r['kind']} {r['scope']}"
|
|
+ (f" until {r['expires_at']}" if r["expires_at"] else " (standing)")
|
|
+ (f" overriding {r['conflicts']}" if r["conflicts"] else ""))
|
|
elif cmd == "release":
|
|
if args.claim_id is None and not args.scope:
|
|
raise HarborError("give a claim id or --scope")
|
|
out(harbor.release(who(), args.claim_id, args.scope), "released")
|
|
elif cmd == "claims":
|
|
rows = harbor.active_claims(agent=args.filter_agent, kind=args.kind)
|
|
out(rows, "\n".join(f"#{c['id']:>4} {c['agent']:<9} {c['kind']:<7} {c['scope']:<32}"
|
|
+ (f" until {c['expires_at']}" if c['expires_at'] else " standing")
|
|
+ (f" {c['note']}" if c['note'] else "") for c in rows) or "No active claims.")
|
|
elif cmd == "submit":
|
|
r = harbor.submit(who(), args.title, scope=args.scope, commit=args.commit, branch=args.branch, note=args.note,
|
|
reviewers=args.reviewer, task=args.task)
|
|
out(r, f"review item #{r['id']} submitted (thread {r['thread_id']})")
|
|
elif cmd == "review":
|
|
r = harbor.transition(who(), args.item, args.state, note=args.note, commit=args.commit)
|
|
out(r, f"item #{r['id']} is now {r['state']}")
|
|
elif cmd == "withdraw":
|
|
r = harbor.transition(who(), args.item, "withdrawn", note=args.note)
|
|
out(r, f"item #{r['id']} withdrawn")
|
|
elif cmd == "land":
|
|
if len(args.item) == 1 and harbor.item(args.item[0])[0]["state"] == "approved":
|
|
r = harbor.transition(who(), args.item[0], "landed", note=args.note, commit=args.commit)
|
|
out(r, f"item #{r['id']} landed in {args.commit}")
|
|
else: # approves items still under review on the way
|
|
r = harbor.land_many(who(), args.item, args.commit, note=args.note)
|
|
out(r, f"{len(r)} items landed in {args.commit}: " + ", ".join(f"#{i['id']}" for i in r))
|
|
elif cmd == "item":
|
|
item, events = harbor.item(args.item)
|
|
out({"item": item, "events": events},
|
|
f"#{item['id']} {item['state']} {item['scope'] or ''} {item['title']} (author {item['author']}, "
|
|
f"commit {item['commit_hash'] or '-'})\n" + "\n".join(
|
|
f" {e['at']} {e['agent']}: {e['from_state'] or '-'} -> {e['to_state']}"
|
|
+ (f" ({e['commit_hash']})" if e['commit_hash'] else "") + (f" {e['note']}" if e['note'] else "")
|
|
for e in events))
|
|
elif cmd == "queue":
|
|
rows = harbor.items(states=ITEM_STATES if args.all else OPEN_ITEM_STATES)
|
|
out(rows, "\n".join(f"#{i['id']:>4} {i['state']:<17} {i['author']:<9} {i['scope'] or '':<18} {i['title']}"
|
|
f" (since {i['created_at'][:16]}Z)" for i in rows) or "The review queue is empty.")
|
|
elif cmd == "status":
|
|
flags = harbor.flags()
|
|
stopped = [a for a in project.ai_names if harbor.stopped(a)]
|
|
trials = {a: harbor.trial(a) for a in project.ai_names if harbor.trial(a)}
|
|
lines = [f"{project.title}: " + (f"stopped: {', '.join(stopped)}" if stopped else "nobody is stopped")
|
|
+ ("; trial runs: " + ", ".join(f"{a} until {u}" for a, u in trials.items()) if trials else "") + "."]
|
|
agents = harbor.agents()
|
|
for a in agents:
|
|
n, u = harbor.unread_count(a["name"])
|
|
seen = harbor.minutes_since(a["last_seen"])
|
|
lines.append(f" {a['name']:<9} unread {n:>3}" + (f" ({u} urgent)" if u else " ")
|
|
+ f" seen {'never' if seen is None else str(seen) + ' min ago':<14}"
|
|
+ (f" doing: {a['doing']}" if a.get("doing") else ""))
|
|
lines.append(f"Review queue: {len(harbor.items())} open. Active claims: {len(harbor.active_claims())}.")
|
|
for a in harbor.attention():
|
|
lines.append(f"Attention: {a['text']}")
|
|
out({"flags": flags, "agents": agents, "queue": len(harbor.items()), "attention": harbor.attention()},
|
|
"\n".join(lines))
|
|
elif cmd == "digest":
|
|
d = harbor.digest(args.since)
|
|
lines = [f"From {d['since']} to {d['until']}:"]
|
|
for a in d["agents"]:
|
|
if any(a[k] for k in ("messages", "submitted", "reviewed", "landed", "claims")):
|
|
lines.append(f" {a['name']:<9} {a['messages']:>3} messages in {a['threads']} threads, "
|
|
f"{a['submitted']} submitted, {a['reviewed']} reviewed, {a['landed']} landed, "
|
|
f"{a['claims']} claims" + (f"; now: {a['doing']}" if a["doing"] else ""))
|
|
for e in d["item_events"]:
|
|
lines.append(f" item #{e['item_id']} {e['title']}: {e['from_state'] or '-'} -> {e['to_state']} by {e['agent']}")
|
|
for f in d["flags"]:
|
|
lines.append(f" {f['key']} {f['value']} by {f['set_by']} at {f['at']}" + (f": {f['reason']}" if f['reason'] else ""))
|
|
if d["to_human"]:
|
|
lines.append(f"Messages to {project.human}: " + ", ".join(f"#{m['id']} from {m['sender']}" for m in d["to_human"]))
|
|
out(d, "\n".join(lines) if len(lines) > 1 else lines[0] + " nothing happened.")
|
|
elif cmd == "attention":
|
|
rows = harbor.attention()
|
|
out(rows, "\n".join(a["text"] for a in rows) or "Nothing needs attention.")
|
|
elif cmd in ("stop", "resume"):
|
|
key = "stop:all" if args.target.lower() == "all" else f"stop:{args.target}"
|
|
flags = harbor.set_flag(key, "on" if cmd == "stop" else "off", who(), "cli", reason=args.reason,
|
|
relay_of=args.relay)
|
|
out(flags, f"{key} is now {flags[key]['value']}")
|
|
elif cmd == "pending-acks":
|
|
rows = harbor.pending_acks(sender=args.agent, overdue_minutes=args.overdue)
|
|
out(rows, "\n".join(f"#{r['id']} from {r['sender']} to {r['agent']} at {r['created_at']}" for r in rows)
|
|
or "Nothing waiting for acknowledgement.")
|
|
elif cmd == "import-legacy":
|
|
if who() not in project.coordinators:
|
|
raise HarborError("only a coordinator imports chat history")
|
|
r = harbor.import_legacy(args.path)
|
|
out(r, f"parsed {r['parsed']} messages, imported {r['added']} new")
|
|
elif cmd == "tasks":
|
|
states = TASK_STATES if args.all else ("open", "in_progress", "blocked", "review")
|
|
rows = harbor.tasks(states=states, assignee=(who() if args.mine else args.filter_agent))
|
|
out(rows, "\n".join(fmt_task(x) for x in rows) or "No tasks.")
|
|
elif cmd == "task":
|
|
if args.action == "bulk":
|
|
text = sys.stdin.read() if not args.file or args.file == "-" else Path(args.file).read_text(encoding="utf-8")
|
|
r = harbor.bulk_tasks(who(), text, template=args.template, priority=args.priority, assignee=args.for_agent)
|
|
out(r, "\n".join(["added " + fmt_task(x).strip() for x in r["created"]] + [f"skipped: {s}" for s in r["skipped"]])
|
|
or "nothing to add")
|
|
elif args.action == "template":
|
|
if not args.args:
|
|
raise HarborError("task template <name> [scope]")
|
|
rows = harbor.run_template(who(), args.args[0], scope=args.args[1] if len(args.args) > 1 else None,
|
|
title=args.body, owner=args.for_agent, priority=args.priority)
|
|
out(rows, "\n".join("added " + fmt_task(x).strip() for x in rows))
|
|
elif args.action == "add":
|
|
title = " ".join(args.args)
|
|
body = Path(args.file).read_text(encoding="utf-8") if args.file else args.body
|
|
r = harbor.add_task(who(), title, body=body, scope=args.scope, assignee=args.for_agent,
|
|
priority=args.priority, after=args.after, due=args.due)
|
|
out(r, "added " + fmt_task(r).strip())
|
|
else:
|
|
if len(args.args) != 1 or not args.args[0].isdigit():
|
|
raise HarborError(f"task {args.action} needs one task id")
|
|
tid = int(args.args[0])
|
|
if args.action == "show":
|
|
task, events = harbor.task(tid)
|
|
out({"task": task, "events": events}, fmt_task(task) + (f"\n{task['body']}" if task["body"] else "")
|
|
+ "\n" + "\n".join(f" {e['at']} {e['agent']}: {e['from_state'] or '-'} -> {e['to_state']}"
|
|
+ (f" ({e['note']})" if e['note'] else "") for e in events))
|
|
elif args.action == "take":
|
|
r = harbor.take_task(who(), tid, args.note)
|
|
out(r, "took " + fmt_task(r).strip())
|
|
else:
|
|
state = {"done": "done", "block": "blocked", "release": "open", "cancel": "cancelled",
|
|
"reopen": "open"}[args.action]
|
|
r = harbor.update_task(who(), tid, state, note=args.note)
|
|
out(r, fmt_task(r).strip())
|
|
elif cmd == "next":
|
|
r = harbor.next_task(who(), take=not args.peek)
|
|
if r and r["scope"]:
|
|
r["context"] = harbor.context_text(r["scope"])
|
|
out(r, ("next: " if args.peek else "took ") + fmt_task(r).strip() + (f"\n\n{r['context']}" if r.get("context")
|
|
else "") if r else
|
|
"No task you can take right now (all assigned, waiting on other tasks, inside someone else's claim, "
|
|
"or you are stopped).")
|
|
elif cmd == "ask":
|
|
q = harbor.ask(who(), " ".join(args.question), options=(args.options or "").split("|") if args.options else (),
|
|
to=args.to, due=args.due, fallback=args.fallback, thread=args.thread)
|
|
out(q, f"question #{q['id']} sent to {q['to_name']} (message #{q['message_id']}); `wait` returns when it is "
|
|
"answered")
|
|
elif cmd == "answer":
|
|
q = harbor.answer(who(), args.question_id, " ".join(args.text))
|
|
out(q, f"answered #{q['id']}: {q['answer']}")
|
|
elif cmd == "questions":
|
|
me = who()
|
|
rows = [q for q in harbor.questions(open_only=not args.all, limit=100) if me in (q["to_name"], q["asker"])]
|
|
out(rows, "\n".join(f"#{q['id']} {q['asker']} -> {q['to_name']}: {q['question']}"
|
|
+ (f" [{' / '.join(q['options'])}]" if q["options"] else "")
|
|
+ (f" => {q['answer']} ({q['answered_by']})" if q["answer"] else "") for q in rows)
|
|
or "No open questions.")
|
|
elif cmd == "note":
|
|
r = harbor.note(who(), args.scope, " ".join(args.text), replaces=args.replaces)
|
|
out(r, f"note #{r['id']} on {r['scope']}")
|
|
elif cmd == "notes":
|
|
rows = harbor.notes(args.scope)
|
|
out(rows, "\n".join(f"#{n['id']} {n['scope']} {n['author']} {n['created_at'][:10]}: {n['body']}" for n in rows)
|
|
or "No notes.")
|
|
elif cmd == "context":
|
|
out(harbor.context(args.scope), harbor.context_text(args.scope, limit=15))
|
|
elif cmd == "metric":
|
|
r = harbor.metric(who(), args.name, args.value, args.note)
|
|
out(r, f"{r['name']} = {r['value']:g}")
|
|
elif cmd == "metrics":
|
|
rows = harbor.metrics()
|
|
out(rows, "\n".join(f"{k:<20} {v['latest']['value']:g} ({v['latest']['by_agent']}, {v['latest']['at']})"
|
|
+ (f" {v['latest']['note']}" if v['latest']['note'] else "") for k, v in rows.items())
|
|
or "No metrics yet.")
|
|
elif cmd == "pulse":
|
|
data = harbor.pulse(hours=args.hours)
|
|
hours = {}
|
|
for agent, buckets in data["agents"].items():
|
|
for b in buckets:
|
|
hours.setdefault(agent, {}).setdefault(b["bucket"][:13], 0)
|
|
hours[agent][b["bucket"][:13]] += b["tools"] + b["messages"]
|
|
marks = " .:-=+*#%@"
|
|
stamps = sorted({h for row in hours.values() for h in row})
|
|
lines = [f"Activity per hour since {data['since']} (UTC hours {stamps[0][11:13] if stamps else '-'}"
|
|
f"..{stamps[-1][11:13] if stamps else '-'}):"]
|
|
for agent in harbor.agent_names():
|
|
row = hours.get(agent, {})
|
|
peak = max(row.values() or [1])
|
|
lines.append(f" {agent:<9} " + "".join(marks[min(9, int(9 * row.get(h, 0) / peak + 0.99))] if row.get(h) else " "
|
|
for h in stamps))
|
|
out(data, "\n".join(lines))
|
|
elif cmd == "wins":
|
|
rows = harbor.wins(args.since)
|
|
out(rows, "\n".join(f"{w['at']} #{w['item_id']} {w['title']} by {w['author']}" for w in rows) or "No wins yet.")
|
|
elif cmd == "git":
|
|
radar = harbor.git_radar()
|
|
lines = []
|
|
for agent, g in radar.items():
|
|
if not g:
|
|
continue
|
|
if g.get("error"):
|
|
lines.append(f"{agent:<9} {g['workdir']}: {g['error']}")
|
|
continue
|
|
last = g["last_commit"]
|
|
lines.append(f"{agent:<9} {g['branch']:<18} last {last['sha']} {harbor.minutes_since(last['at'])} min ago: "
|
|
f"{last['subject'][:60]}")
|
|
lines.append(f"{'':<9} {g['dirty']} uncommitted, {g['behind_main']} behind main, "
|
|
f"{len(g['unsubmitted'])} commit(s) since the last submit")
|
|
out(radar, "\n".join(lines) or "No agent has a workdir in the project file.")
|
|
elif cmd == "summarize":
|
|
text = Path(args.file).read_text(encoding="utf-8") if args.file else " ".join(args.text)
|
|
r = harbor.summarize(who(), args.thread, text)
|
|
out(r, f"summary #{r['id']} pinned to {r['thread']}")
|
|
elif cmd == "re":
|
|
from .reverse import Ghidra, Reverse
|
|
r = None if args.action.startswith(("ghidra", "debugger", "match", "behaviour")) else Reverse(harbor.project.reverse)
|
|
if args.action == "behaviour":
|
|
from .reverse import behaviour_check
|
|
res = behaviour_check(harbor.project.reverse, args.target, args.decomp)
|
|
out(res, "\n".join(f"{r['address']} {r.get('verdict', ''):<8} {r.get('name', '')} {r.get('reason') or ''}" for r in res))
|
|
elif args.action in ("similar", "struct-audit"):
|
|
from .reverse import run_toolkit
|
|
res = (run_toolkit(harbor.project.reverse, "similar", [args.target]) if args.action == "similar" else
|
|
run_toolkit(harbor.project.reverse, "struct_audit", ["--struct", args.target], json_to_file=True))
|
|
out(res, json.dumps(res, indent=1))
|
|
elif args.action == "match":
|
|
from .reverse import match_functions
|
|
res = match_functions(harbor.project.reverse, args.target, args.decomp)
|
|
out(res, res["summary"] + "\n" + "\n".join(
|
|
f"{x['address']} {x['status']:<9} {x.get('similarity', '')!s:<6} {x['file']} {x.get('note', '')}"
|
|
for x in res["results"]))
|
|
elif args.action == "debugger-tools":
|
|
from .reverse import Debugger
|
|
res = Debugger(harbor.project.reverse).tools()
|
|
out(res, "\n".join(f"{t['name']:<22} {(t['description'] or '').splitlines()[0][:90] if t['description'] else ''}"
|
|
for t in res))
|
|
elif args.action == "ghidra-tools":
|
|
res = Ghidra(harbor.project.reverse).tools()
|
|
out(res, "\n".join(f"{t['name']:<26} {t['description'].splitlines()[0][:90]}" for t in res))
|
|
elif args.action == "ghidra":
|
|
text = Ghidra(harbor.project.reverse).call(args.target, json.loads(args.arguments))
|
|
out({"result": text}, text)
|
|
elif args.action == "disasm":
|
|
text = r.disassemble(args.target, args.max_bytes)
|
|
out({"disassembly": text}, text)
|
|
elif args.action == "xrefs":
|
|
res = r.xrefs(args.target)
|
|
out(res, json.dumps(res, indent=1))
|
|
elif args.action == "bytes":
|
|
res = r.bytes_at(args.target, args.count, args.as_type)
|
|
out(res, json.dumps(res, indent=1))
|
|
else:
|
|
res = r.lookup(args.target)
|
|
out(res, json.dumps(res, indent=1))
|
|
elif cmd == "logbook":
|
|
from . import logbook
|
|
project = harbor.project
|
|
if args.action in ("add", "stats", "map", "milestone", "import", "refresh") and who() not in harbor.coordinators:
|
|
raise HarborError("the Logbook is written by a coordinator")
|
|
text = Path(args.file).read_text(encoding="utf-8") if args.file and args.action != "import" else None
|
|
if args.action == "add":
|
|
res = logbook.add_entry(project, args.title, args.detail or text, kind=args.kind)
|
|
out(res, f"logged {res['id']}: {res['title']}")
|
|
elif args.action == "stats":
|
|
res = logbook.set_stats(project, json.loads(text), history_point=not args.no_history)
|
|
out(res, "statistics updated")
|
|
elif args.action == "map":
|
|
res = logbook.set_map(project, json.loads(text))
|
|
out(res, f"chart updated ({res['cells']} cells)")
|
|
elif args.action == "milestone":
|
|
res = logbook.upsert_milestone(project, json.loads(text))
|
|
out(res, f"milestone {res['id']} saved")
|
|
elif args.action == "refresh":
|
|
from . import logbook_auto
|
|
res = logbook_auto.refresh(project, force=True)
|
|
out(res, json.dumps(res))
|
|
elif args.action == "import":
|
|
res = logbook.import_export(project, args.file)
|
|
out(res, json.dumps(res))
|
|
else:
|
|
res = logbook.read_all(project, log_limit=10)
|
|
out(res, "\n".join(f"{e['at'][:16]} [{e['kind']}] {e['title']}" for e in res["log"]))
|
|
elif cmd in ("next-functions", "defer", "progress"):
|
|
from .queue import FunctionQueue
|
|
q = FunctionQueue(harbor)
|
|
if cmd == "next-functions":
|
|
rows = q.next_functions(who(), args.n, similar_readable=q.similar_readable())
|
|
out(rows, "\n".join(f"{r['address']:<10} {r['score']:<7} {(r['name'] or r['file'] or ''):<34} {r['why']}"
|
|
for r in rows))
|
|
elif cmd == "defer":
|
|
res = q.defer(who(), args.address, args.reason, args.evidence)
|
|
out(res, f"deferred {args.address}: {args.reason}")
|
|
else:
|
|
res = q.progress()
|
|
out(res, "\n".join(f"{t:<9} {v['functions']:>6} functions {v['bytes']:>9} bytes"
|
|
for t, v in res["tiers"].items()))
|
|
elif cmd == "who":
|
|
rows = harbor.experts(args.scope)
|
|
out(rows, "\n".join(f"{e['agent']:<9} " + ", ".join(f"{v} {k}" for k, v in e["detail"].items()) for e in rows)
|
|
or "Nobody has worked on it yet.")
|
|
elif cmd == "feed":
|
|
rows = harbor.activity_feed(limit=args.limit, agent=args.filter_agent)
|
|
out(rows, "\n".join(f"{r['at'][11:19]} {r['agent']:<9} {r['tool'] or '':<14} {r['target'] or ''}" for r in reversed(rows))
|
|
or "No tool activity recorded yet.")
|
|
elif cmd == "templates":
|
|
out(project.templates, "\n".join(f"{name}: " + " -> ".join(s.get("name", s["title"]) for s in spec["steps"])
|
|
for name, spec in project.templates.items()) or "No templates defined.")
|
|
elif cmd == "export":
|
|
text = harbor.export_thread(args.thread)
|
|
if args.out:
|
|
Path(args.out).write_text(text, encoding="utf-8")
|
|
print(f"wrote {args.out}")
|
|
else:
|
|
print(text)
|
|
elif cmd == "handoff":
|
|
text = Path(args.file).read_text(encoding="utf-8") if args.file else " ".join(args.text)
|
|
r = harbor.handoff(who(), text)
|
|
out(r, f"handoff #{r['id']} saved; it opens your next brief")
|
|
elif cmd == "handoffs":
|
|
rows = harbor.handoffs(agent=args.filter_agent, limit=args.limit)
|
|
out(rows, "\n\n".join(f"#{h['id']} {h['agent']} at {h['created_at']}\n" + "\n".join(
|
|
" " + line for line in h["body"].split("\n")) for h in rows) or "No handoffs.")
|
|
elif cmd in ("pin", "unpin"):
|
|
rows = harbor.pin(who(), args.message_id, args.note) if cmd == "pin" else harbor.unpin(who(), args.message_id)
|
|
out(rows, f"{len(rows)} pinned message(s)")
|
|
elif cmd in ("pins", "decisions"):
|
|
rows = harbor.pins() if cmd == "pins" else harbor.decisions()
|
|
out(rows, "\n\n".join(fmt_message(m) for m in rows) or f"No {cmd}.")
|
|
elif cmd == "prompt":
|
|
text = harbor.restart_prompt(args.agent_name)
|
|
out({"prompt": text}, text)
|
|
elif cmd == "doctor":
|
|
from . import doctor
|
|
checks = doctor.run(project, harbor)
|
|
out(checks, doctor.render(checks))
|
|
elif cmd == "backup":
|
|
path = harbor.backup(keep=args.keep)
|
|
out({"backup": str(path)}, f"backed up to {path}")
|
|
|
|
|
|
def run():
|
|
try:
|
|
main()
|
|
except (HarborError, projects.ProjectError) as error:
|
|
sys.exit(f"harbor: {error}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
run()
|