patchwarden 1.1.0 → 1.5.1

package/src/tools/dispatch/goalDispatch.ts

@@ -0,0 +1,127 @@
+/**
+ * Dispatch handlers for Goal Session tools (v0.8.0+).
+ *
+ * Covers goal lifecycle, subgoal management, Spec Kit import,
+ * worktree merge/discard, and goal reporting.
+ */
+
+import { createGoal, listGoals, readGoal, readGoalStatus } from "../../goal/goalStore.js";
+import { suggestNextSubgoal } from "../../goal/goalGraph.js";
+import { exportHandoff } from "../../goal/handoffExport.js";
+import { acceptSubgoal, rejectSubgoal, summarizeGoalProgress } from "../../goal/goalProgress.js";
+import { exportGoalReport } from "../../goal/goalReport.js";
+import { importSpecKitTasks, parseSpecKitJson } from "../../goal/specKitImport.js";
+import { createSubgoalTask } from "../goalSubgoalTask.js";
+import { mergeWorktreeTool } from "../mergeWorktree.js";
+import { discardWorktreeTool } from "../discardWorktree.js";
+import type { ToolHandlerMap } from "./types.js";
+import { toResult } from "./types.js";
+
+export const goalHandlers: ToolHandlerMap = {
+  create_goal: async (args) => {
+    return toResult(
+      createGoal(
+        String(args?.repo_path ?? ""),
+        String(args?.title ?? ""),
+        String(args?.goal_description ?? ""),
+      ),
+    );
+  },
+
+  list_goals: async () => {
+    return toResult({ goals: listGoals() });
+  },
+
+  read_goal: async (args) => {
+    return toResult(readGoal(String(args?.goal_id ?? "")));
+  },
+
+  create_subgoal_task: async (args) => {
+    return toResult(
+      await createSubgoalTask({
+        goal_id: String(args?.goal_id ?? ""),
+        subgoal_title: String(args?.subgoal_title ?? ""),
+        depends_on: Array.isArray(args?.depends_on) ? args.depends_on.map(String) : undefined,
+        plan_id: args?.plan_id ? String(args.plan_id) : undefined,
+        inline_plan: args?.inline_plan ? String(args.inline_plan) : undefined,
+        plan_title: args?.plan_title ? String(args.plan_title) : undefined,
+        template: args?.template ? (String(args.template) as any) : undefined,
+        goal: args?.goal ? String(args.goal) : undefined,
+        agent: args?.agent ? String(args.agent) : undefined,
+        repo_path: String(args?.repo_path ?? ""),
+        test_command: args?.test_command ? String(args.test_command) : undefined,
+        verify_commands: Array.isArray(args?.verify_commands)
+          ? args.verify_commands.map(String)
+          : undefined,
+        timeout_seconds: args?.timeout_seconds ? Number(args.timeout_seconds) : undefined,
+        scope: Array.isArray(args?.scope) ? args.scope.map(String) : undefined,
+        forbidden: Array.isArray(args?.forbidden) ? args.forbidden.map(String) : undefined,
+        verification: Array.isArray(args?.verification) ? args.verification.map(String) : undefined,
+        done_evidence: Array.isArray(args?.done_evidence) ? args.done_evidence.map(String) : undefined,
+        isolate_worktree:
+          args?.isolate_worktree === undefined ? undefined : Boolean(args.isolate_worktree),
+      }),
+    );
+  },
+
+  accept_subgoal: async (args) => {
+    return toResult(
+      acceptSubgoal(String(args?.goal_id ?? ""), String(args?.subgoal_id ?? "")),
+    );
+  },
+
+  reject_subgoal: async (args) => {
+    return toResult(
+      rejectSubgoal(
+        String(args?.goal_id ?? ""),
+        String(args?.subgoal_id ?? ""),
+        String(args?.reason ?? ""),
+      ),
+    );
+  },
+
+  suggest_next_subgoal: async (args) => {
+    const goalStatus = readGoalStatus(String(args?.goal_id ?? ""));
+    return toResult(suggestNextSubgoal(goalStatus));
+  },
+
+  summarize_goal_progress: async (args) => {
+    return toResult(summarizeGoalProgress(String(args?.goal_id ?? "")));
+  },
+
+  export_handoff: async (args) => {
+    const goalId = String(args?.goal_id ?? "");
+    const goalStatus = readGoalStatus(goalId);
+    return toResult(exportHandoff(goalId, goalStatus));
+  },
+
+  export_goal_report: async (args) => {
+    const goalId = String(args?.goal_id ?? "");
+    return toResult(exportGoalReport(goalId));
+  },
+
+  import_speckit_tasks: async (args) => {
+    const goalId = String(args?.goal_id ?? "");
+    const jsonText = String(args?.spec_kit_json ?? "");
+    const input = parseSpecKitJson(jsonText);
+    return toResult(importSpecKitTasks(goalId, input));
+  },
+
+  merge_worktree: async (args) => {
+    return toResult(
+      mergeWorktreeTool({
+        worktree_id: String(args?.worktree_id ?? ""),
+        repo_path: String(args?.repo_path ?? ""),
+      }),
+    );
+  },
+
+  discard_worktree: async (args) => {
+    return toResult(
+      discardWorktreeTool({
+        worktree_id: String(args?.worktree_id ?? ""),
+        repo_path: String(args?.repo_path ?? ""),
+      }),
+    );
+  },
+};

package/src/tools/dispatch/releaseDispatch.ts

@@ -0,0 +1,65 @@
+/**
+ * Dispatch handlers for release-mode tools (v1.3.0+).
+ *
+ * Wraps releaseCheck, releasePrepare, releaseVerify, and releaseCleanup
+ * from releaseMode.ts.
+ */
+
+import {
+  releaseCheck,
+  releasePrepare,
+  releaseVerify,
+  releaseCleanup,
+} from "../releaseMode.js";
+import type { ToolHandlerMap } from "./types.js";
+import { toResult } from "./types.js";
+
+export const releaseHandlers: ToolHandlerMap = {
+  release_check: async (args) => {
+    return toResult(
+      await releaseCheck({
+        repo_path: String(args?.repo_path ?? ""),
+        target_stage: String(args?.target_stage ?? "local_ready") as any,
+        package_name: args?.package_name ? String(args.package_name) : undefined,
+        version: args?.version ? String(args.version) : undefined,
+        github_repo: args?.github_repo ? String(args.github_repo) : undefined,
+        branch: args?.branch ? String(args.branch) : undefined,
+      }),
+    );
+  },
+
+  release_prepare: async (args) => {
+    return toResult(
+      releasePrepare({
+        repo_path: String(args?.repo_path ?? ""),
+        required_commands: Array.isArray(args?.required_commands)
+          ? args.required_commands.map(String)
+          : undefined,
+        timeout_seconds:
+          args?.timeout_seconds !== undefined ? Number(args.timeout_seconds) : undefined,
+      }),
+    );
+  },
+
+  release_verify: async (args) => {
+    return toResult(
+      await releaseVerify({
+        repo_path: String(args?.repo_path ?? ""),
+        package_name: args?.package_name ? String(args.package_name) : undefined,
+        version: args?.version ? String(args.version) : undefined,
+        github_repo: args?.github_repo ? String(args.github_repo) : undefined,
+        branch: args?.branch ? String(args.branch) : undefined,
+      }),
+    );
+  },
+
+  release_cleanup: async (args) => {
+    return toResult(
+      releaseCleanup({
+        repo_path: String(args?.repo_path ?? ""),
+        dry_run: args?.dry_run !== undefined ? Boolean(args.dry_run) : undefined,
+        patterns: Array.isArray(args?.patterns) ? args.patterns.map(String) : undefined,
+      }),
+    );
+  },
+};

package/src/tools/dispatch/types.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared types and helpers for the dispatch map.
+ *
+ * Each domain dispatch file exports a `ToolHandlerMap` whose handlers
+ * directly call the existing tool functions — no logic is rewritten.
+ */
+
+export type ToolHandler = (
+  args: Record<string, unknown> | undefined,
+) => Promise<{ content: Array<{ type: string; text: string }> }>;
+
+export type ToolHandlerMap = Record<string, ToolHandler>;
+
+/**
+ * Wrap a plain data value into the MCP CallToolResult content envelope.
+ * Mirrors the original `toResult` helper from registry.ts.
+ */
+export function toResult(data: unknown): {
+  content: Array<{ type: string; text: string }>;
+} {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+  };
+}