scribeclock 0.0.0-stage → 0.1.0

package/dist/commands/files.js

@@ -0,0 +1,210 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { CliError, usageError } from "../cli/errors.js";
+import { fmtDate } from "../util/format.js";
+import { PROJECT_FLAG, bool, cmd, emit, guardedEmit, num, personName, projectArg, requirePositional, str } from "./_shared.js";
+export const filesLs = cmd({
+    path: "files ls",
+    group: "Files",
+    summary: "List files: a project's Drive/files (--project) or the organization's Files tab (folder, path or search).",
+    tool: ["list_project_files", "list_organization_files"],
+    positionals: [{ name: "path", description: "Files-tab folder path such as Documents/Specs (organization mode)." }],
+    flags: [
+        PROJECT_FLAG,
+        { name: "folder", type: "string", placeholder: "<id>", description: "Files-tab folder id." },
+        { name: "query", alias: "q", type: "string", description: "Search the whole organization by name." },
+        { name: "limit", alias: "n", type: "number", description: "Max items (default 50)." },
+    ],
+    examples: ["scribeclock files ls --project 'Scribe Clock'", "scribeclock files ls Documents/Specs", "scribeclock files ls -q invoice"],
+    async run(ctx, inv) {
+        const project = str(inv.flags.project);
+        if (project || (!inv.positionals[0] && !inv.flags.folder && !inv.flags.query && ctx.repo.config.project)) {
+            const project_id = project ?? ctx.repo.config.project;
+            const data = await ctx.call("list_project_files", { project_id });
+            return emit(ctx, data, () => {
+                const files = (data.files ?? data.items ?? []);
+                ctx.out.log(ctx.out.bold(`${String(data.project_name ?? project_id)} — ${files.length} file${files.length === 1 ? "" : "s"}`) + ctx.out.dim(` (${data.google_drive_connected || data.has_google_drive ? "Google Drive linked" : "ScribeClock drive"}${data.can_write === false ? ", read-only" : ""})`));
+                ctx.out.table(["id", "title", "type", "storage", "link"], files.map((f) => [f.id ?? f.drive_file_id, f.title ?? f.name, f.mime_type, f.storage, f.web_view_link ?? f.url]));
+            });
+        }
+        const data = await ctx.call("list_organization_files", { folder_path: inv.positionals[0], folder_id: str(inv.flags.folder), query: str(inv.flags.query), limit: num(inv.flags.limit) });
+        return emit(ctx, data, () => {
+            const files = (data.files ?? []);
+            ctx.out.table(["id", "name", "kind", "size", "uploaded by", "updated", "staff only"], files.map((f) => [f.id, f.is_folder ? `${String(f.name)}/` : f.name, f.is_folder ? "folder" : (f.mime_type ?? "file"), f.size_bytes ?? f.size ?? "", personName(f.uploaded_by), fmtDate(String(f.updated_at ?? "")), f.staff_only ? "yes" : ""]));
+        });
+    },
+});
+function textBlocks(content) {
+    return content
+        .filter((c) => c.type === "text")
+        .map((c) => c.text)
+        .join("\n");
+}
+async function downloadChunks(ctx, tool, baseArgs, out) {
+    const parts = [];
+    let offset = 0;
+    let expected;
+    for (let guard = 0; guard < 1000; guard++) {
+        const page = await ctx.call(tool, { ...baseArgs, byte_offset: offset, byte_length: 2 * 1024 * 1024 });
+        if (typeof page.sha256 === "string")
+            expected = page.sha256;
+        const b64 = typeof page.content_base64 === "string" ? page.content_base64 : "";
+        if (b64)
+            parts.push(Buffer.from(b64, "base64"));
+        const next = page.next_byte_offset;
+        if (next === null || next === undefined || Number(next) <= offset)
+            break;
+        offset = Number(next);
+        ctx.out.info(ctx.out.dim(`…${Math.round(offset / 1024)} KB`));
+    }
+    const buf = Buffer.concat(parts);
+    writeFileSync(out, buf);
+    const actual = createHash("sha256").update(buf).digest("hex");
+    return { bytes: buf.length, sha256: expected, ok: !expected || expected === actual };
+}
+export const filesGet = cmd({
+    path: "files get",
+    group: "Files",
+    summary: "Read a file as text (default) or download it with --out; big files stream in verified chunks.",
+    tool: ["read_project_file", "read_organization_file"],
+    positionals: [{ name: "file", required: true, description: "File id / title (project) or Files-tab item id (organization)." }],
+    flags: [
+        PROJECT_FLAG,
+        { name: "out", alias: "o", type: "string", placeholder: "<path>", description: "Save the original bytes to this path (chunked download for big files)." },
+        { name: "max-chars", type: "number", description: "Text length per call (default 100000)." },
+    ],
+    examples: ["scribeclock files get <id>", "scribeclock files get 'Architecture notes' --project 'Scribe Clock'", "scribeclock files get <id> --out ./spec.pdf"],
+    async run(ctx, inv) {
+        const file = requirePositional(inv, 0, "A file id", "scribeclock files get <id>");
+        const project_id = str(inv.flags.project) ?? (/^[0-9a-f-]{36}$/i.test(file) ? undefined : ctx.repo.config.project);
+        if (project_id) {
+            const data = await ctx.call("read_project_file", { project_id, file_id: file, max_chars: num(inv.flags["max-chars"]) });
+            if (inv.flags.out) {
+                const text = String(data.text ?? data.content ?? "");
+                writeFileSync(String(inv.flags.out), text);
+                ctx.out.log(`Saved ${text.length} characters to ${String(inv.flags.out)}.`);
+                return 0;
+            }
+            return emit(ctx, data, () => ctx.out.log(String(data.text ?? data.content ?? JSON.stringify(data, null, 2))));
+        }
+        if (inv.flags.out) {
+            const res = await downloadChunks(ctx, "read_organization_file", { file_id: file }, String(inv.flags.out));
+            if (!res.ok)
+                throw new CliError(`Checksum mismatch after download (expected sha256 ${res.sha256}).`, { id: "checksum_mismatch" });
+            if (ctx.flags.json)
+                ctx.out.jsonOut({ ok: true, path: inv.flags.out, bytes: res.bytes, sha256: res.sha256 });
+            else
+                ctx.out.log(`${ctx.out.green("✓")} Saved ${res.bytes} bytes to ${String(inv.flags.out)}${res.sha256 ? ctx.out.dim(` (sha256 verified)`) : ""}.`);
+            return 0;
+        }
+        const outcome = await ctx.callRaw("read_organization_file", { file_id: file, max_chars: num(inv.flags["max-chars"]) });
+        if (!outcome.ok) {
+            const { toolError } = await import("../context.js");
+            throw toolError("read_organization_file", outcome);
+        }
+        const data = outcome.data;
+        if (ctx.flags.json) {
+            ctx.out.jsonOut(data);
+            return 0;
+        }
+        if (typeof data.text === "string") {
+            ctx.out.log(data.text);
+            if (data.next_text_offset)
+                ctx.out.info(ctx.out.dim(`… more text: --max-chars or the raw tool with --text-offset ${String(data.next_text_offset)}`));
+        }
+        else {
+            const extra = textBlocks(outcome.content.filter((c) => c.type === "text" && !c.text.startsWith("{")));
+            if (extra)
+                ctx.out.log(extra);
+            ctx.out.log(ctx.out.dim(`${String(data.mime_type ?? "binary")}, ${String(data.total_bytes ?? "?")} bytes${data.rendered ? ` (${String(data.rendered)})` : ""}. Download it with --out <path>.`));
+        }
+        return 0;
+    },
+});
+const TEXT_EXT = new Set([".md", ".markdown", ".txt", ".csv", ".json", ".yaml", ".yml", ".html", ".htm", ".ts", ".js", ".py", ".sql", ".xml", ".toml", ".ini", ".env", ".log"]);
+export const filesPut = cmd({
+    path: "files put",
+    group: "Files",
+    summary: "Upload a file to a project (--project) or write a text/Markdown document into the Files tab.",
+    tool: ["upload_project_file", "create_document"],
+    positionals: [{ name: "path", required: true, description: "Local file to upload." }],
+    flags: [
+        PROJECT_FLAG,
+        { name: "name", type: "string", description: "Stored file name (default: the local name)." },
+        { name: "folder", type: "string", placeholder: "<id|path>", description: "Drive folder id (project) or Files-tab folder path (organization)." },
+        { name: "google-doc", type: "boolean", description: "Convert text to a native Google Doc (project with Drive)." },
+        { name: "restricted", type: "boolean", description: "Project file visibility: restricted instead of all assignees." },
+        { name: "staff-only", type: "boolean", description: "Files tab: hide from non-staff members." },
+    ],
+    examples: ["scribeclock files put ./notes.md --project 'Scribe Clock'", "scribeclock files put ./spec.md --folder Documents/Specs"],
+    async run(ctx, inv) {
+        const path = requirePositional(inv, 0, "A file path", "scribeclock files put ./notes.md --project X");
+        if (!existsSync(path))
+            throw usageError(`No such file: ${path}`);
+        const bytes = readFileSync(path);
+        if (bytes.length > 5 * 1024 * 1024)
+            throw usageError("Files are limited to 5 MB here.", "Attach bigger files to a task with `scribeclock tasks attach` (up to 25 MB).");
+        const filename = str(inv.flags.name) ?? basename(path);
+        const ext = extname(filename).toLowerCase();
+        const isText = TEXT_EXT.has(ext);
+        const project_id = str(inv.flags.project) ?? ctx.repo.config.project;
+        if (project_id) {
+            const data = await ctx.call("upload_project_file", { project_id, filename, ...(isText ? { content: bytes.toString("utf8") } : { content_base64: bytes.toString("base64") }), folder_id: str(inv.flags.folder), as_google_doc: bool(inv.flags["google-doc"]), visibility: inv.flags.restricted ? "restricted" : undefined });
+            return emit(ctx, data, () => ctx.out.log(`${ctx.out.green("✓")} Uploaded ${filename} (${(bytes.length / 1024).toFixed(0)} KB) to ${String(data.project_name ?? project_id)}${data.web_view_link || data.url ? ctx.out.dim(`  ${String(data.web_view_link ?? data.url)}`) : ""}`));
+        }
+        if (!isText && ext !== ".docx")
+            throw usageError("Without --project only text documents (.md, .txt, .html, .csv, .json…) or .docx can be written to the Files tab.", "Pass --project <id|name> to upload any file into a project.");
+        const format = ext === ".docx" ? "docx" : ext === ".html" || ext === ".htm" ? "html" : ext === ".md" || ext === ".markdown" ? "markdown" : "text";
+        const data = await ctx.call("create_document", { title: filename.replace(/\.[^.]+$/, ""), destination: "files", format, ...(ext === ".docx" ? { content_base64: bytes.toString("base64") } : { content: bytes.toString("utf8") }), folder_path: str(inv.flags.folder), staff_only: bool(inv.flags["staff-only"]) });
+        return emit(ctx, data, () => ctx.out.log(`${ctx.out.green("✓")} Saved ${filename} to the Files tab${data.url ? ctx.out.dim(`  ${String(data.url)}`) : ""}`));
+    },
+});
+export const filesRm = cmd({
+    path: "files rm",
+    group: "Files",
+    summary: "Permanently delete a Files-tab item (asks; --dry-run shows what would go).",
+    tool: "delete_organization_file",
+    positionals: [{ name: "id", required: true, description: "Files-tab item id." }],
+    async run(ctx, inv) {
+        const file_id = requirePositional(inv, 0, "A file id", "scribeclock files rm <id>");
+        return guardedEmit(ctx, "delete_organization_file", { file_id }, (data) => ctx.out.log(`${ctx.out.green("✓")} Deleted ${String(data.name ?? file_id)}.`));
+    },
+});
+export const docsNew = cmd({
+    path: "docs new",
+    group: "Meetings & docs",
+    summary: "Create a document from Markdown: docs new --from spec.md [--project P] [--format docx|google_doc|markdown|html].",
+    tool: "create_document",
+    flags: [
+        { name: "from", alias: "f", type: "string", placeholder: "<file.md|->", description: "Markdown source (- for stdin).", required: true },
+        { name: "title", alias: "t", type: "string", description: "Document title (default: first heading or the file name)." },
+        PROJECT_FLAG,
+        { name: "format", type: "string", choices: ["google_doc", "docx", "markdown", "html", "text"], description: "Output format (default: Google Doc in a project with Drive, else Markdown)." },
+        { name: "dest", type: "string", choices: ["project_drive", "files"], description: "Where it goes (default: project drive when a project has Drive, else Files tab)." },
+        { name: "folder", type: "string", placeholder: "<path|id>", description: "Files-tab folder path (created if missing) or Drive folder id." },
+        { name: "task", type: "string", placeholder: "<#123>", description: "Also comment the link on this task." },
+        { name: "staff-only", type: "boolean", description: "Files tab: staff only." },
+    ],
+    examples: ["scribeclock docs new --from release-notes.md --project 'Scribe Clock' --format docx", "cat notes.md | scribeclock docs new --from - --title 'Standup notes' --folder Documents/Standups"],
+    async run(ctx, inv) {
+        const from = String(inv.flags.from);
+        const content = from === "-" ? readFileSync(0, "utf8") : readFileSync(from, "utf8");
+        const heading = /^#\s+(.+)$/m.exec(content)?.[1]?.trim();
+        const title = str(inv.flags.title) ?? heading ?? (from === "-" ? "Document" : basename(from).replace(/\.[^.]+$/, ""));
+        const folder = str(inv.flags.folder);
+        const data = await ctx.call("create_document", {
+            title,
+            content,
+            project_id: projectArg(ctx, inv),
+            format: str(inv.flags.format),
+            destination: str(inv.flags.dest),
+            folder_path: folder && !/^[0-9a-f-]{36}$/i.test(folder) ? folder : undefined,
+            folder_id: folder && /^[0-9a-f-]{36}$/i.test(folder) ? folder : undefined,
+            task_id: str(inv.flags.task),
+            staff_only: bool(inv.flags["staff-only"]),
+        });
+        return emit(ctx, data, () => ctx.out.log(`${ctx.out.green("✓")} Created "${title}"${data.format ? ` (${String(data.format)})` : ""}${data.url || data.web_view_link ? ctx.out.dim(`  ${String(data.url ?? data.web_view_link)}`) : ""}`));
+    },
+});
+export const FILE_COMMANDS = [filesLs, filesGet, filesPut, filesRm, docsNew];

package/dist/commands/gitflow.js

@@ -0,0 +1,208 @@
+import { spawnSync } from "node:child_process";
+import { CliError, usageError } from "../cli/errors.js";
+import { changedFiles, currentBranch, detectTaskKey, git, gitState, githubSlug, hooksPath, lastCommit, remoteUrl, repoRef, tagDate } from "../git.js";
+import { EXIT } from "../types.js";
+import { fmtDate, parseWhen, slugify } from "../util/format.js";
+import { PROJECT_FLAG, bool, cmd, emit, list, personName, projectIdArg, str, taskKey } from "./_shared.js";
+/** feat/123-short-title — the prefix comes from .scribeclock.json → branch_prefix (default feat). */
+export function branchNameFor(ctx, task, prefix) {
+    const p = prefix ?? ctx.repo.config.branch_prefix ?? "feat";
+    const num = task.key.replace(/^#/, "");
+    const slug = slugify(task.title, 40);
+    return `${p}/${num}${slug ? `-${slug}` : ""}`;
+}
+/** This repository refuses branches (hooks in .githooks, CLAUDE.md "main only"). */
+export function repoForbidsBranches(ctx) {
+    const hooks = hooksPath(ctx.cwd);
+    if (hooks && /githooks/.test(hooks)) {
+        const check = git(["config", "--get", "scribeclock.allowBranches"], ctx.cwd);
+        return check !== "true";
+    }
+    return false;
+}
+export const branchCommand = cmd({
+    path: "branch",
+    group: "Git",
+    summary: "Print (or, with --create, create) a conventionally named branch for a task: feat/123-short-title.",
+    description: "Prints the branch name a task would get. Branch creation is opt-in (--create) and off by default: repositories that work on main only (git hooks under .githooks) refuse it unless `git config scribeclock.allowBranches true`.",
+    tool: "get_task",
+    positionals: [{ name: "task", required: true, description: "Task key, uuid or auto." }],
+    flags: [
+        { name: "create", alias: "c", type: "boolean", description: "Create and switch to the branch (opt-in)." },
+        { name: "prefix", type: "string", description: "Branch prefix (default: .scribeclock.json → branch_prefix, else feat)." },
+    ],
+    examples: ["scribeclock branch #731", "scribeclock branch 731 --create --prefix fix"],
+    async run(ctx, inv) {
+        const task_id = taskKey(ctx, inv.positionals[0]);
+        const data = await ctx.call("get_task", { task_id, comment_limit: 0 });
+        const t = (data.task ?? data);
+        const name = branchNameFor(ctx, { key: String(t.key ?? task_id), title: String(t.title ?? "") }, str(inv.flags.prefix));
+        if (!inv.flags.create)
+            return emit(ctx, { ok: true, branch: name, task: { key: t.key, title: t.title }, created: false }, () => ctx.out.log(name));
+        if (repoForbidsBranches(ctx))
+            throw new CliError("This repository works on main only (its git hooks refuse new branches).", { id: "branches_forbidden", hint: "Keep committing on main, or allow branches here with: git config scribeclock.allowBranches true" });
+        if (ctx.flags.dryRun)
+            return emit(ctx, { ok: true, branch: name, dry_run: true }, () => ctx.out.log(`${ctx.out.dim("dry run →")} git switch -c ${name}`));
+        const r = spawnSync("git", ["switch", "-c", name], { cwd: ctx.cwd, encoding: "utf8" });
+        if (r.status !== 0)
+            throw new CliError(`git switch -c ${name} failed: ${(r.stderr || r.stdout).trim()}`, { id: "git_failed" });
+        return emit(ctx, { ok: true, branch: name, created: true }, () => ctx.out.log(`${ctx.out.green("✓")} On new branch ${ctx.out.bold(name)}`));
+    },
+});
+export const commitCommand = cmd({
+    path: "commit",
+    group: "Git",
+    summary: 'git commit with the task key in the message, then post the commit as progress: commit -m "msg" [--task #12].',
+    description: "Runs `git commit` (staged changes; -a to stage tracked changes) with the task key appended as (#123), then reports progress on the task with the commit as evidence (skip with --no-report). The task defaults to the one in the branch name or last commit.",
+    tool: "report_task_progress",
+    flags: [
+        { name: "message", alias: "m", type: "string", description: "Commit message.", required: true },
+        { name: "task", alias: "t", type: "string", description: "Task key (default: detected from git)." },
+        { name: "all", alias: "a", type: "boolean", description: "Stage modified/deleted tracked files first (git commit -a)." },
+        { name: "no-report", type: "boolean", description: "Only commit; do not post progress." },
+        { name: "amend", type: "boolean", description: "Amend the previous commit." },
+    ],
+    examples: ['scribeclock commit -m "Wire Stripe webhook" --task #730', 'scribeclock commit -am "Fix DNS record" '],
+    async run(ctx, inv) {
+        const message = String(inv.flags.message);
+        const explicit = str(inv.flags.task);
+        const detected = explicit ? null : detectTaskKey(ctx.cwd);
+        const key = explicit ? taskKey(ctx, explicit) : detected?.key;
+        if (!key)
+            throw usageError("No task given and none detected from the branch or last commit.", "Pass --task #123.");
+        const full = new RegExp(`(^|[^0-9])${key.replace("#", "#")}(?![0-9])`).test(message) ? message : `${message} (${key})`;
+        const args = ["commit", "-m", full];
+        if (inv.flags.all)
+            args.splice(1, 0, "-a");
+        if (inv.flags.amend)
+            args.push("--amend");
+        if (ctx.flags.dryRun) {
+            ctx.out.log(`${ctx.out.dim("dry run →")} git ${args.map((a) => (a.includes(" ") ? JSON.stringify(a) : a)).join(" ")}`);
+            return EXIT.OK;
+        }
+        const r = spawnSync("git", args, { cwd: ctx.cwd, encoding: "utf8" });
+        if (r.status !== 0)
+            throw new CliError(`git commit failed: ${(r.stderr || r.stdout).trim()}`, { id: "git_failed", hint: "Stage your changes first (git add …) or pass -a." });
+        const commit = lastCommit(ctx.cwd);
+        ctx.out.info(`${ctx.out.green("✓")} ${commit?.sha.slice(0, 10) ?? ""} ${full}`);
+        if (inv.flags["no-report"])
+            return emit(ctx, { ok: true, commit, reported: false }, () => undefined);
+        const slug = githubSlug(remoteUrl(ctx.cwd));
+        const data = await ctx.call("report_task_progress", {
+            task_id: key,
+            outcome: "progress",
+            summary: `Committed: ${message}`,
+            evidence: commit ? [{ kind: "commit", title: full.slice(0, 80), detail: `${commit.sha.slice(0, 10)} ${full}`.slice(0, 300), url: slug ? `https://github.com/${slug}/commit/${commit.sha}` : undefined }] : [],
+            repo: repoRef(ctx.cwd) ?? undefined,
+            branch: currentBranch(ctx.cwd) ?? undefined,
+            files_changed: changedFiles(ctx.cwd),
+            last_commit: commit ? { sha: commit.sha, message: full.slice(0, 300) } : undefined,
+            git: gitState(ctx.cwd),
+        });
+        return emit(ctx, { ok: true, commit, reported: true, report: data }, () => ctx.out.log(`${ctx.out.green("✓")} Progress posted on ${key}.`));
+    },
+});
+export const prCommand = cmd({
+    path: "pr",
+    group: "Git",
+    summary: "Open a GitHub pull request for a task (title + task link + summary) and attach it to the task as evidence.",
+    description: "Needs the GitHub CLI (`gh`) and a pushed branch. The PR title is \"#123 Task title\", the body links the ScribeClock task; the PR url is then reported on the task (outcome=progress, pull_request evidence).",
+    tool: ["get_task", "report_task_progress"],
+    positionals: [{ name: "task", description: "Task key (default: detected from git)." }],
+    flags: [
+        { name: "base", alias: "B", type: "string", description: "Base branch (default: the repository default)." },
+        { name: "draft", type: "boolean", description: "Open as a draft." },
+        { name: "body", type: "string", description: "Extra body text (@file reads a file)." },
+        { name: "no-report", type: "boolean", description: "Do not post the PR on the task." },
+    ],
+    examples: ["scribeclock pr #731", "scribeclock pr --draft"],
+    async run(ctx, inv) {
+        const key = taskKey(ctx, inv.positionals[0]);
+        const branch = currentBranch(ctx.cwd);
+        if (!branch || branch === "main" || branch === "master")
+            throw usageError(`You are on ${branch ?? "no branch"}; a pull request needs a feature branch.`, "scribeclock branch #123 --create");
+        const which = spawnSync("gh", ["--version"], { encoding: "utf8" });
+        if (which.status !== 0)
+            throw new CliError("The GitHub CLI (gh) is not installed.", { id: "gh_missing", hint: "Install it from https://cli.github.com and run gh auth login." });
+        const data = await ctx.call("get_task", { task_id: key, comment_limit: 0 });
+        const t = (data.task ?? data);
+        const title = `${String(t.key ?? key)} ${String(t.title ?? "")}`.trim();
+        const extra = typeof inv.flags.body === "string" ? (inv.flags.body.startsWith("@") ? (await import("node:fs")).readFileSync(inv.flags.body.slice(1), "utf8") : inv.flags.body) : "";
+        const body = [`ScribeClock task: ${String(t.url ?? key)}`, "", typeof t.description === "string" ? t.description.split("\n").slice(0, 12).join("\n") : "", extra].filter(Boolean).join("\n\n");
+        const args = ["pr", "create", "--title", title, "--body", body];
+        if (inv.flags.base)
+            args.push("--base", String(inv.flags.base));
+        if (inv.flags.draft)
+            args.push("--draft");
+        if (ctx.flags.dryRun) {
+            ctx.out.log(`${ctx.out.dim("dry run →")} gh ${args.map((a) => (a.includes(" ") || a.includes("\n") ? JSON.stringify(a.slice(0, 60)) : a)).join(" ")}`);
+            return EXIT.OK;
+        }
+        const r = spawnSync("gh", args, { cwd: ctx.cwd, encoding: "utf8" });
+        if (r.status !== 0)
+            throw new CliError(`gh pr create failed: ${(r.stderr || r.stdout).trim()}`, { id: "gh_failed", hint: "Push the branch first (git push -u origin HEAD) and make sure gh is logged in." });
+        const url = (r.stdout.trim().split("\n").pop() ?? "").trim();
+        ctx.out.info(`${ctx.out.green("✓")} ${url}`);
+        if (inv.flags["no-report"])
+            return emit(ctx, { ok: true, url, reported: false }, () => undefined);
+        const report = await ctx.call("report_task_progress", { task_id: key, outcome: "progress", summary: `Opened pull request ${url}`, evidence: [{ kind: "pull_request", title, url }], repo: repoRef(ctx.cwd) ?? undefined, branch, git: gitState(ctx.cwd) });
+        return emit(ctx, { ok: true, url, reported: true, report }, () => ctx.out.log(`${ctx.out.green("✓")} Pull request attached to ${String(t.key ?? key)}.`));
+    },
+});
+export const changelogCommand = cmd({
+    path: "changelog",
+    group: "Git",
+    summary: "Release notes from completed tasks: changelog --since v1.2.0 (a tag, commit or date) [--project P].",
+    tool: "list_tasks",
+    flags: [
+        { name: "since", type: "string", placeholder: "<tag|ref|date>", description: "Tasks completed after this git tag/commit's date, or a date (YYYY-MM-DD, 14d).", required: true },
+        { name: "until", type: "string", placeholder: "<tag|ref|date>", description: "Upper bound." },
+        PROJECT_FLAG,
+        { name: "assignee", alias: "a", type: "string", description: "Only one person's tasks." },
+        { name: "heading", type: "string", description: "Title line (default: Changes since <since>)." },
+        { name: "group-by", type: "string", choices: ["project", "category", "none"], description: "Grouping (default project)." },
+    ],
+    examples: ["scribeclock changelog --since v1.61.0 > CHANGES.md", "scribeclock changelog --since 14d --project 'Scribe Clock' --group-by category"],
+    async run(ctx, inv) {
+        const resolveBound = (raw) => {
+            if (!raw)
+                return undefined;
+            const fromGit = tagDate(ctx.cwd, raw);
+            if (fromGit)
+                return new Date(fromGit);
+            const d = parseWhen(raw, ctx.now());
+            if (!d)
+                throw usageError(`"${raw}" is neither a git ref nor a date.`);
+            return d;
+        };
+        const since = resolveBound(String(inv.flags.since));
+        const until = resolveBound(str(inv.flags.until));
+        const data = await ctx.call("list_tasks", { status: "completed", updated_since: since.toISOString(), order_by: "updated", limit: 200, project_id: await projectIdArg(ctx, inv), assignee: str(inv.flags.assignee) });
+        const tasks = (data.tasks ?? []).filter((t) => t.completed_at && new Date(String(t.completed_at)) >= since && (!until || new Date(String(t.completed_at)) < until));
+        const groupBy = str(inv.flags["group-by"]) ?? "project";
+        const groups = new Map();
+        for (const t of tasks) {
+            const g = groupBy === "none" ? "" : groupBy === "category" ? String(t.category ?? "general") : (t.project?.name ?? "General");
+            groups.set(g, [...(groups.get(g) ?? []), t]);
+        }
+        const heading = str(inv.flags.heading) ?? `Changes since ${String(inv.flags.since)}${until ? ` until ${String(inv.flags.until)}` : ""}`;
+        const lines = [`# ${heading}`, "", `_${tasks.length} completed task${tasks.length === 1 ? "" : "s"}, ${fmtDate(since.toISOString())} → ${until ? fmtDate(until.toISOString()) : "now"}_`, ""];
+        for (const [g, items] of [...groups.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+            if (g)
+                lines.push(`## ${g}`, "");
+            for (const t of items.sort((a, b) => String(a.completed_at).localeCompare(String(b.completed_at)))) {
+                lines.push(`- ${String(t.title)} ([${String(t.key)}](${String(t.url ?? "")}))${t.assignee ? ` — ${personName(t.assignee)}` : ""}`);
+            }
+            lines.push("");
+        }
+        if (ctx.flags.json)
+            ctx.out.jsonOut({ ok: true, since: since.toISOString(), until: until?.toISOString() ?? null, count: tasks.length, tasks, markdown: lines.join("\n") });
+        else
+            ctx.out.log(lines.join("\n").trimEnd());
+        return EXIT.OK;
+    },
+});
+export const GITFLOW_COMMANDS = [branchCommand, commitCommand, prCommand, changelogCommand];
+void bool;
+void list;
+void JSON;

package/dist/commands/index.js

@@ -0,0 +1,35 @@
+import { Registry } from "../cli/registry.js";
+import { loginCommand, logoutCommand, whoamiCommand } from "./auth.js";
+import { completionsCommand, helpCommand, versionCommand } from "./meta.js";
+import { callCommand, refreshCommand, toolsCommand } from "./tools.js";
+import { TASK_COMMANDS } from "./tasks.js";
+import { CLOCK_COMMANDS } from "./clock.js";
+import { PROJECT_COMMANDS } from "./projects.js";
+import { MEETING_COMMANDS } from "./meetings.js";
+import { FILE_COMMANDS } from "./files.js";
+import { VAULT_COMMANDS } from "./vault.js";
+import { CF_COMMANDS } from "./cf.js";
+import { TEAM_COMMANDS } from "./team.js";
+import { WORKFLOW_COMMANDS } from "./workflow.js";
+import { GITFLOW_COMMANDS } from "./gitflow.js";
+import { OPS_COMMANDS } from "./ops.js";
+import { AUTOMATION_COMMANDS } from "./automation.js";
+/** Every built-in command. Server tools are added dynamically by main() from the catalog. */
+export function buildRegistry() {
+    const registry = new Registry();
+    registry.add(loginCommand, logoutCommand, whoamiCommand, helpCommand, versionCommand, completionsCommand);
+    registry.add(...WORKFLOW_COMMANDS);
+    registry.add(...CLOCK_COMMANDS);
+    registry.add(...TASK_COMMANDS);
+    registry.add(...GITFLOW_COMMANDS);
+    registry.add(...PROJECT_COMMANDS);
+    registry.add(...MEETING_COMMANDS);
+    registry.add(...FILE_COMMANDS);
+    registry.add(...VAULT_COMMANDS);
+    registry.add(...CF_COMMANDS);
+    registry.add(...TEAM_COMMANDS);
+    registry.add(...OPS_COMMANDS);
+    registry.add(...AUTOMATION_COMMANDS);
+    registry.add(toolsCommand, callCommand, refreshCommand);
+    return registry;
+}