@voybio/ace-swarm 0.1.0

package/dist/tools-git.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Git tool registrations – commit, diff, log, and status via git-ops module.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGitTools(server: McpServer): void;
+//# sourceMappingURL=tools-git.d.ts.map

package/dist/tools-git.js

@@ -0,0 +1,183 @@
+/**
+ * Git tool registrations – commit, diff, log, and status via git-ops module.
+ */
+import { z } from "zod";
+import { gitCommit, gitDiff, gitInitIfNeeded, gitLog, gitStatus, } from "./git-ops.js";
+import { appendRunLedgerEntrySafe } from "./run-ledger.js";
+import { appendStatusEventSafe } from "./status-events.js";
+export function registerGitTools(server) {
+    server.tool("git_status", "Get git repository status (staged, unstaged, untracked files, current branch)", {}, async () => {
+        const result = gitStatus();
+        if (!result.ok) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ ${result.error ?? "git status failed"}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        "# Git Status",
+                        "",
+                        `Branch: ${result.branch}`,
+                        `Clean: ${result.clean}`,
+                        "",
+                        result.staged.length > 0
+                            ? `## Staged (${result.staged.length})\n${result.staged.map((f) => `- ${f}`).join("\n")}`
+                            : "",
+                        result.unstaged.length > 0
+                            ? `## Unstaged (${result.unstaged.length})\n${result.unstaged.map((f) => `- ${f}`).join("\n")}`
+                            : "",
+                        result.untracked.length > 0
+                            ? `## Untracked (${result.untracked.length})\n${result.untracked.map((f) => `- ${f}`).join("\n")}`
+                            : "",
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("git_commit", "Stage files and create a git commit with a message", {
+        message: z.string().describe("Commit message"),
+        paths: z
+            .array(z.string())
+            .optional()
+            .describe("Specific file paths to stage (default: all)"),
+    }, async ({ message, paths }) => {
+        const init = gitInitIfNeeded();
+        if (init.initialized) {
+            await appendStatusEventSafe({
+                source_module: "capability-git",
+                event_type: "GIT_INITIALIZED",
+                status: "done",
+                summary: "Git repository initialized",
+            });
+        }
+        const result = gitCommit(message, paths);
+        if (!result.ok) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ ${result.error ?? "git commit failed"}\n${result.output}`,
+                    },
+                ],
+            };
+        }
+        const ledger = await appendRunLedgerEntrySafe({
+            tool: "git_commit",
+            category: "major_update",
+            message: `Git commit: ${result.hash ?? "no-hash"} — ${message}`,
+            artifacts: paths ?? ["(all staged)"],
+            metadata: {
+                hash: result.hash,
+                files_committed: result.files_committed,
+            },
+        });
+        await appendStatusEventSafe({
+            source_module: "capability-git",
+            event_type: "GIT_COMMITTED",
+            status: "done",
+            summary: `Committed ${result.files_committed} file(s): ${message}`,
+            objective_id: "git-commit",
+            payload: {
+                hash: result.hash,
+                files_committed: result.files_committed,
+                evidence_ref: `git:${result.hash ?? "HEAD"}`,
+            },
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        "✅ Committed",
+                        `Hash: ${result.hash}`,
+                        `Files: ${result.files_committed}`,
+                        `Message: ${message}`,
+                        `Run ledger: ${ledger.path} (${ledger.entry.id})`,
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("git_diff", "Show git diff for workspace or specific file", {
+        path: z.string().optional().describe("Specific file path to diff"),
+        staged: z
+            .boolean()
+            .optional()
+            .describe("Show staged changes instead of working directory"),
+    }, async ({ path, staged }) => {
+        const result = gitDiff(path, staged);
+        if (!result.ok) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ ${result.error ?? "git diff failed"}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `# Git Diff${staged ? " (staged)" : ""}${path ? ` — ${path}` : ""}`,
+                        "",
+                        `Files changed: ${result.files_changed}`,
+                        `Insertions: ${result.insertions}`,
+                        `Deletions: ${result.deletions}`,
+                        "",
+                        "```diff",
+                        result.diff,
+                        "```",
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    server.tool("git_log", "Show recent git commit history", {
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe("Number of commits to show (default: 20)"),
+    }, async ({ limit }) => {
+        const result = gitLog(limit ?? 20);
+        if (!result.ok) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `❌ ${result.error ?? "git log failed"}`,
+                    },
+                ],
+            };
+        }
+        const lines = result.entries.map((e) => `- \`${e.hash.slice(0, 8)}\` ${e.date.slice(0, 10)} ${e.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `# Git Log (${result.entries.length} commits)`,
+                        "",
+                        ...lines,
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+}
+//# sourceMappingURL=tools-git.js.map

package/dist/tools-handoff.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Handoff management tool registrations.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { HandoffRecord } from "./handoff-registry.js";
+import { DispatchJobsResult } from "./job-scheduler.js";
+export interface HandoffSchedulerSyncResult {
+    ok: boolean;
+    job_id: string;
+    enqueued: boolean;
+    enqueue_reason?: string;
+    tick: DispatchJobsResult;
+}
+export interface HandoffSchedulerBackfillResult {
+    scanned: number;
+    synced: number;
+    enqueued: number;
+    failures: {
+        handoff_id: string;
+        error: string;
+    }[];
+}
+export declare function syncHandoffIntoScheduler(record: HandoffRecord, options?: {
+    owner?: string;
+    now_iso?: string;
+}): Promise<HandoffSchedulerSyncResult>;
+export declare function backfillHandoffsIntoScheduler(options?: {
+    owner?: string;
+    now_iso?: string;
+}): Promise<HandoffSchedulerBackfillResult>;
+export declare function registerHandoffTools(server: McpServer): void;
+//# sourceMappingURL=tools-handoff.d.ts.map