@brainervirus/workit-core 0.5.6 → 0.6.1

package/src/tools/handoff.ts

@@ -37,10 +37,11 @@ export const adaptPluginHandoffClient = (client: PluginInput["client"]): Handoff
     promptAsync: (input) => client.session.promptAsync(input),
   },
   tui: {
-    selectSession: ({ body, query }) => client.tui.publish({
-      body: { type: "tui.session.select", properties: { sessionID: body.sessionID } } as never,
-      query,
-    }),
+    selectSession: ({ body, query }) =>
+      client.tui.publish({
+        body: { type: "tui.session.select", properties: { sessionID: body.sessionID } } as never,
+        query,
+      }),
   },
 });
 
@@ -58,11 +59,12 @@ type HandoffData = {
   stage?: "create" | "seed" | "select";
 };
 
-const message = (error: unknown) => error instanceof Error
-  ? error.message
-  : typeof error === "object" && error !== null && "message" in error
-    ? String(error.message)
-    : String(error);
+const message = (error: unknown) =>
+  error instanceof Error
+    ? error.message
+    : typeof error === "object" && error !== null && "message" in error
+      ? String(error.message)
+      : String(error);
 const apiError = (response: ApiResponse<unknown> | void) => response?.error;
 
 export async function handoffSession(
@@ -121,21 +123,22 @@ export const buildHandoffPrompt = (root: string, message: string): HandoffContex
     path.dirname(fileURLToPath(import.meta.url)),
     "../../templates/execution-contract.md",
   );
-  const contract = buildHandoffContract({ root, spec: resolved.spec, plan: resolved.plan, templatePath });
+  const contract = buildHandoffContract({
+    root,
+    spec: resolved.spec,
+    plan: resolved.plan,
+    templatePath,
+  });
   if ("error" in contract) return { error: contract.error };
   const sdd = `docs/${path.basename(path.dirname(resolved.plan))}/sdd`;
   return { prompt: contract.prompt, spec: resolved.spec, plan: resolved.plan, sdd };
 };
 
-
-
-export function createHandoffTools(
-  client: HandoffClient,
-  state: WorkflowStateStore,
-) {
+export function createHandoffTools(client: HandoffClient, state: WorkflowStateStore) {
   return {
     workflow_handoff_session: tool({
-      description: "Create, seed, and select a continuation session; --stay in the message skips selection",
+      description:
+        "Create, seed, and select a continuation session; --stay in the message skips selection",
       args: { message: tool.schema.string() },
       execute: async ({ message: userMessage }, context) => {
         const built = buildHandoffPrompt(context.directory, userMessage);
@@ -145,12 +148,14 @@ export function createHandoffTools(
           const gate = assertFlowGates(context.directory, active.plan);
           if (!gate.ok) return output(fail(gate.error));
           state.set(context.sessionID, { spec: active.spec, plan: active.plan, sdd: active.sdd });
-          return output(await handoffSession(client, {
-            directory: context.directory,
-            title: `Continue ${path.basename(path.dirname(active.plan))}`,
-            prompt: active.prompt,
-            stay: /(?:^|\s)--stay(?:\s|$)/.test(userMessage),
-          }));
+          return output(
+            await handoffSession(client, {
+              directory: context.directory,
+              title: `Continue ${path.basename(path.dirname(active.plan))}`,
+              prompt: active.prompt,
+              stay: /(?:^|\s)--stay(?:\s|$)/.test(userMessage),
+            }),
+          );
         } catch (error) {
           return output(fail(message(error)));
         }

package/src/tools/present.ts

@@ -24,16 +24,20 @@ export function createPresentTools() {
       args: {
         title: tool.schema.string().optional(),
         direction: tool.schema.enum(["TD", "LR", "BT", "RL"]).optional(),
-        nodes: tool.schema.array(tool.schema.object({
-          id: tool.schema.string(),
-          label: tool.schema.string(),
-          shape: tool.schema.string().optional(),
-        })),
-        edges: tool.schema.array(tool.schema.object({
-          from: tool.schema.string(),
-          to: tool.schema.string(),
-          label: tool.schema.string().optional(),
-        })),
+        nodes: tool.schema.array(
+          tool.schema.object({
+            id: tool.schema.string(),
+            label: tool.schema.string(),
+            shape: tool.schema.string().optional(),
+          }),
+        ),
+        edges: tool.schema.array(
+          tool.schema.object({
+            from: tool.schema.string(),
+            to: tool.schema.string(),
+            label: tool.schema.string().optional(),
+          }),
+        ),
       },
       execute: async (spec) => {
         const result = flowDiagram(spec);

package/src/tools/repo.ts

@@ -8,7 +8,13 @@ import { gitContext } from "../core/git";
 import { parseKeyValueLines, parseSections } from "../core/parse-sections";
 import { parseVerifyOutput } from "../core/verify-parse";
 import { branchSetup } from "../core/branch";
-import { configDir, readConfig, writeConfig, type BranchPreset, type ToolkitConfig } from "../core/config";
+import {
+  configDir,
+  readConfig,
+  writeConfig,
+  type BranchPreset,
+  type ToolkitConfig,
+} from "../core/config";
 import { ensureProjectGitignore } from "../core/gitignore";
 import { ensureHygieneFiles } from "../core/hygiene";
 
@@ -22,46 +28,67 @@ export type RepoRuntime = {
 };
 
 const defaultRuntime: RepoRuntime = {
-  runScript: (root, script, args, env) => run(root, "bash", [path.join(scripts, script), ...args], env),
+  runScript: (root, script, args, env) =>
+    run(root, "bash", [path.join(scripts, script), ...args], env),
   git: (root, args) => run(root, "git", args),
 };
 
 const output = (value: unknown) => JSON.stringify(value, null, 2);
 const diagnostics = ({ stdout, stderr, exitCode }: RunResult) => ({ stdout, stderr, exitCode });
-const requireConfirmed = (confirmed: boolean) => confirmed === true ? null : output(fail("confirmed: true required"));
+const requireConfirmed = (confirmed: boolean) =>
+  confirmed === true ? null : output(fail("confirmed: true required"));
 import { resolveBranchPolicy } from "../core/config";
 const branchPolicy = () => resolveBranchPolicy(readConfig());
 
 function scriptResult<T extends object>(result: RunResult, parse: (stdout: string) => T) {
   if (result.exitCode !== 0) {
-    return fail(result.stderr.trim() || result.stdout.trim() || "workflow script failed", diagnostics(result));
+    return fail(
+      result.stderr.trim() || result.stdout.trim() || "workflow script failed",
+      diagnostics(result),
+    );
   }
   try {
-    return ok({ ...parse(result.stdout), exitCode: 0, ...(result.stderr ? { stderr: result.stderr } : {}) });
+    return ok({
+      ...parse(result.stdout),
+      exitCode: 0,
+      ...(result.stderr ? { stderr: result.stderr } : {}),
+    });
   } catch (error) {
-    return fail(error instanceof Error ? error.message : "workflow output parse failed", diagnostics(result));
+    return fail(
+      error instanceof Error ? error.message : "workflow output parse failed",
+      diagnostics(result),
+    );
   }
 }
 
 const json = (stdout: string) => JSON.parse(stdout.trim()) as Record<string, unknown>;
 const legacyScriptResult = (result: RunResult) => {
   let parsed: Record<string, unknown> | null = null;
-  try { parsed = json(result.stdout); } catch { /* handled below */ }
-  if (result.exitCode !== 0 || parsed?.error || parsed?.ok === false) return fail(
-    parsed?.error
-      ? String(parsed.error)
-      : parsed?.ok === false
-        ? "legacy operation reported failure"
-        : result.stderr.trim() || result.stdout.trim() || "workflow script failed",
-    diagnostics(result),
-  );
+  try {
+    parsed = json(result.stdout);
+  } catch {
+    /* handled below */
+  }
+  if (result.exitCode !== 0 || parsed?.error || parsed?.ok === false)
+    return fail(
+      parsed?.error
+        ? String(parsed.error)
+        : parsed?.ok === false
+          ? "legacy operation reported failure"
+          : result.stderr.trim() || result.stdout.trim() || "workflow script failed",
+      diagnostics(result),
+    );
   if (!parsed) return fail("workflow output parse failed", diagnostics(result));
   const { ok: _legacyOk, ...data } = parsed;
   return ok({ ...data, exitCode: 0, ...(result.stderr ? { stderr: result.stderr } : {}) });
 };
 const optionalJson = (value: string | undefined) => {
   if (!value?.trim()) return null;
-  try { return JSON.parse(value); } catch { return null; }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
 };
 const sections = (stdout: string) => parseSections(stdout) as Record<string, string>;
 export const normalizeLegacyResult = (value: Record<string, unknown>) => {
@@ -74,7 +101,13 @@ export const normalizeLegacyResult = (value: Record<string, unknown>) => {
 const parsePr = (stdout: string) => {
   const part = sections(stdout);
   const repo = parseKeyValueLines(part.Repository ?? "", [
-    "branch", "range", "base_ref", "merge_base", "diff_range", "range_mode", "git_sync",
+    "branch",
+    "range",
+    "base_ref",
+    "merge_base",
+    "diff_range",
+    "range_mode",
+    "git_sync",
   ]);
   return {
     ...repo,
@@ -128,27 +161,44 @@ const parseDocs = (stdout: string) => {
 export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
   const validateRange = (root: string, value: string) => {
     for (const revision of gitRevisionParts(value)) {
-      const resolved = runtime.git(root, ["rev-parse", "--verify", "--quiet", "--end-of-options", `${revision}^{commit}`]);
+      const resolved = runtime.git(root, [
+        "rev-parse",
+        "--verify",
+        "--quiet",
+        "--end-of-options",
+        `${revision}^{commit}`,
+      ]);
       if (resolved.exitCode !== 0) throw new Error(`invalid Git revision or range: ${value}`);
     }
   };
   const contextWithRange = (
-    root: string, script: string, value: string | undefined,
+    root: string,
+    script: string,
+    value: string | undefined,
     parse: (stdout: string) => Record<string, unknown>,
   ) => {
-    try { if (value) validateRange(root, value); }
-    catch (error) { return output(fail(error instanceof Error ? error.message : "invalid Git revision or range")); }
+    try {
+      if (value) validateRange(root, value);
+    } catch (error) {
+      return output(fail(error instanceof Error ? error.message : "invalid Git revision or range"));
+    }
     return output(scriptResult(runtime.runScript(root, script, value ? [value] : []), parse));
   };
-  const invoke = (script: string, parse: (stdout: string) => Record<string, unknown>, args: string[] = []) =>
-    async (_input: unknown, context: ToolContext) => output(scriptResult(runtime.runScript(context.directory, script, args), parse));
+  const invoke =
+    (script: string, parse: (stdout: string) => Record<string, unknown>, args: string[] = []) =>
+    async (_input: unknown, context: ToolContext) =>
+      output(scriptResult(runtime.runScript(context.directory, script, args), parse));
 
   return {
     workflow_toolkit_init_status: tool({
-      description: "Inspect toolkit initialization", args: {}, execute: invoke("init/status.sh", json),
+      description: "Inspect toolkit initialization",
+      args: {},
+      execute: invoke("init/status.sh", json),
     }),
     workflow_toolkit_status: tool({
-      description: "Inspect toolkit and repository state", args: {}, execute: invoke("init/toolkit-status.sh", json),
+      description: "Inspect toolkit and repository state",
+      args: {},
+      execute: invoke("init/toolkit-status.sh", json),
     }),
     workflow_git_context: tool({
       description: "Read Git branch and change context",
@@ -158,42 +208,62 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
     workflow_verify: tool({
       description: "Discover and run repository verification",
       args: { dry_run: tool.schema.boolean().optional() },
-      execute: async ({ dry_run }, context) => output(scriptResult(
-        runtime.runScript(context.directory, "verify-project.sh", dry_run ? ["--dry-run"] : []), parseVerifyOutput,
-      )),
+      execute: async ({ dry_run }, context) =>
+        output(
+          scriptResult(
+            runtime.runScript(context.directory, "verify-project.sh", dry_run ? ["--dry-run"] : []),
+            parseVerifyOutput,
+          ),
+        ),
     }),
     workflow_pr_context: tool({
       description: "Gather branch-exclusive PR context",
       args: { range: tool.schema.string().optional() },
-      execute: async ({ range }, context) => contextWithRange(context.directory, "pr-ready-context.sh", range, parsePr),
+      execute: async ({ range }, context) =>
+        contextWithRange(context.directory, "pr-ready-context.sh", range, parsePr),
     }),
     workflow_changelog_context: tool({
       description: "Gather changelog context",
       args: { range: tool.schema.string().optional() },
-      execute: async ({ range }, context) => contextWithRange(context.directory, "changelog-context.sh", range, parseChangelog),
+      execute: async ({ range }, context) =>
+        contextWithRange(context.directory, "changelog-context.sh", range, parseChangelog),
     }),
     workflow_release_notes_context: tool({
       description: "Gather release notes for an explicit range",
       args: { range_or_tag: tool.schema.string() },
-      execute: async ({ range_or_tag }, context) => !range_or_tag.trim()
-        ? output(fail("release tag or range required"))
-        : contextWithRange(context.directory, "release-notes-context.sh", range_or_tag, parseRelease),
+      execute: async ({ range_or_tag }, context) =>
+        !range_or_tag.trim()
+          ? output(fail("release tag or range required"))
+          : contextWithRange(
+              context.directory,
+              "release-notes-context.sh",
+              range_or_tag,
+              parseRelease,
+            ),
     }),
     workflow_docs_context: tool({
       description: "Gather documentation refresh context",
       args: { range: tool.schema.string().optional() },
-      execute: async ({ range }, context) => output(scriptResult(
-        runtime.runScript(context.directory, "docs-refresh-context.sh", range ? [range] : []), parseDocs,
-      )),
+      execute: async ({ range }, context) =>
+        output(
+          scriptResult(
+            runtime.runScript(context.directory, "docs-refresh-context.sh", range ? [range] : []),
+            parseDocs,
+          ),
+        ),
     }),
     workflow_changelog_apply: tool({
       description: "Apply confirmed Keep a Changelog entries to Unreleased",
       args: {
         confirmed: tool.schema.boolean(),
-        entries: tool.schema.union([
-          tool.schema.record(tool.schema.string(), tool.schema.array(tool.schema.string())),
-          tool.schema.array(tool.schema.object({ category: tool.schema.string(), text: tool.schema.string() })),
-        ]).optional(),
+        entries: tool.schema
+          .union([
+            tool.schema.record(tool.schema.string(), tool.schema.array(tool.schema.string())),
+            tool.schema.array(
+              tool.schema.object({ category: tool.schema.string(), text: tool.schema.string() }),
+            ),
+          ])
+          .optional(),
         path: tool.schema.string().optional(),
         normalize_only: tool.schema.boolean().optional(),
       },
@@ -205,9 +275,16 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
         } catch (error) {
           return output(fail(error instanceof Error ? error.message : "invalid changelog path"));
         }
-        return output(normalizeLegacyResult(changelogApply({
-          entries, path: changelogPath, normalize_only, workspace_root: realpathSync(context.directory),
-        }) as Record<string, unknown>));
+        return output(
+          normalizeLegacyResult(
+            changelogApply({
+              entries,
+              path: changelogPath,
+              normalize_only,
+              workspace_root: realpathSync(context.directory),
+            }) as Record<string, unknown>,
+          ),
+        );
       },
     }),
     workflow_branch_setup: tool({
@@ -229,14 +306,20 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
           return output(fail(error instanceof Error ? error.message : "invalid SDD path"));
         }
         const result = branchSetup({
-          action, sdd_dir: resolvedSdd, target_branch, stash, workspace_root: context.directory,
+          action,
+          sdd_dir: resolvedSdd,
+          target_branch,
+          stash,
+          workspace_root: context.directory,
         });
-        return output(legacyScriptResult({
-          stdout: JSON.stringify(result),
-          stderr: "",
-          exitCode: result.error ? 1 : 0,
-          cwd: context.directory,
-        }));
+        return output(
+          legacyScriptResult({
+            stdout: JSON.stringify(result),
+            stderr: "",
+            exitCode: result.error ? 1 : 0,
+            cwd: context.directory,
+          }),
+        );
       },
     }),
     workflow_commit: tool({
@@ -246,15 +329,24 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
         const rejected = requireConfirmed(confirmed);
         if (rejected) return rejected;
         const branch = runtime.git(context.directory, ["branch", "--show-current"]);
-        if (branch.exitCode !== 0) return output(fail(
-          branch.stderr.trim() || branch.stdout.trim() || "unable to read current branch", diagnostics(branch),
-        ));
+        if (branch.exitCode !== 0)
+          return output(
+            fail(
+              branch.stderr.trim() || branch.stdout.trim() || "unable to read current branch",
+              diagnostics(branch),
+            ),
+          );
         const name = branch.stdout.trim();
         const pol = branchPolicy();
-        if (pol.protected.has(name.toLowerCase())) return output(fail(`cannot commit on protected branch ${name}`));
-        if (!pol.allowed.some((r) => r.test(name)) || name.endsWith("/")) return output(fail(`commit requires an allowed branch (current: ${name})`));
-        return output(scriptResult(runtime.git(context.directory, ["commit", "-m", message]),
-          (stdout) => ({ stdout: stdout.trim() })));
+        if (pol.protected.has(name.toLowerCase()))
+          return output(fail(`cannot commit on protected branch ${name}`));
+        if (!pol.allowed.some((r) => r.test(name)) || name.endsWith("/"))
+          return output(fail(`commit requires an allowed branch (current: ${name})`));
+        return output(
+          scriptResult(runtime.git(context.directory, ["commit", "-m", message]), (stdout) => ({
+            stdout: stdout.trim(),
+          })),
+        );
       },
     }),
     workflow_pr_create: tool({
@@ -270,21 +362,29 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
         const rejected = requireConfirmed(confirmed);
         if (rejected) return rejected;
         const branch = runtime.git(context.directory, ["branch", "--show-current"]);
-        if (branch.exitCode !== 0) return output(fail(
-          branch.stderr.trim() || branch.stdout.trim() || "unable to read current branch", diagnostics(branch),
-        ));
+        if (branch.exitCode !== 0)
+          return output(
+            fail(
+              branch.stderr.trim() || branch.stdout.trim() || "unable to read current branch",
+              diagnostics(branch),
+            ),
+          );
         const name = branch.stdout.trim();
         const pol = branchPolicy();
         if (!pol.allowed.some((r) => r.test(name)) || name.endsWith("/")) {
           return output(fail(`PR creation requires an allowed branch (current: ${name})`));
         }
-        return output(legacyScriptResult(runtime.runScript(context.directory, "pr-create.sh", [], {
-          WF_PR_TITLE: title,
-          WF_PR_BODY: body ?? "",
-          WF_PR_CONFIRMED: "true",
-          WF_PR_DRAFT: draft ? "true" : "false",
-          WF_PR_TARGET: target_branch ?? "",
-        })));
+        return output(
+          legacyScriptResult(
+            runtime.runScript(context.directory, "pr-create.sh", [], {
+              WF_PR_TITLE: title,
+              WF_PR_BODY: body ?? "",
+              WF_PR_CONFIRMED: "true",
+              WF_PR_DRAFT: draft ? "true" : "false",
+              WF_PR_TARGET: target_branch ?? "",
+            }),
+          ),
+        );
       },
     }),
     workflow_toolkit_init_apply: tool({
@@ -292,7 +392,13 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
       args: {
         confirmed: tool.schema.boolean(),
         action: tool.schema.enum([
-          "youtrack_scaffold", "youtrack_json", "youtrack_token_placeholder", "vcs_scaffold", "config", "gitignore", "hygiene",
+          "youtrack_scaffold",
+          "youtrack_json",
+          "youtrack_token_placeholder",
+          "vcs_scaffold",
+          "config",
+          "gitignore",
+          "hygiene",
         ]),
         base_url: tool.schema.string().optional(),
         default_mention: tool.schema.string().optional(),
@@ -302,20 +408,39 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
         locale: tool.schema.string().optional(),
         locale_options: tool.schema.array(tool.schema.string()).optional(),
         timezone: tool.schema.string().optional(),
-        branch_policy_preset: tool.schema.enum(["gitflow", "github-flow", "trunk-based", "custom"]).optional(),
+        branch_policy_preset: tool.schema
+          .enum(["gitflow", "github-flow", "trunk-based", "custom"])
+          .optional(),
         branch_policy_allowed: tool.schema.array(tool.schema.string()).optional(),
         branch_policy_protected: tool.schema.array(tool.schema.string()).optional(),
         include_open_source: tool.schema.boolean().optional(),
       },
-      execute: async ({
-        confirmed, action, base_url, default_mention, meeting_issue, vcs_provider, vcs_target_branch,
-        locale, locale_options, timezone, branch_policy_preset, branch_policy_allowed, branch_policy_protected,
-        include_open_source,
-      }, context) => {
+      execute: async (
+        {
+          confirmed,
+          action,
+          base_url,
+          default_mention,
+          meeting_issue,
+          vcs_provider,
+          vcs_target_branch,
+          locale,
+          locale_options,
+          timezone,
+          branch_policy_preset,
+          branch_policy_allowed,
+          branch_policy_protected,
+          include_open_source,
+        },
+        context,
+      ) => {
         const rejected = requireConfirmed(confirmed);
         if (rejected) return rejected;
         if (action === "hygiene") {
-          const result = ensureHygieneFiles(context.directory, { confirmed, includeOpenSource: include_open_source });
+          const result = ensureHygieneFiles(context.directory, {
+            confirmed,
+            includeOpenSource: include_open_source,
+          });
           return output(result.ok ? ok(result) : fail(result.error));
         }
         if (action === "gitignore") {
@@ -325,7 +450,9 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
         if (action === "config") {
           const LOCALE_RE = /^[a-z]{2,3}(-[A-Z]{2})?$/;
           if (locale !== undefined && !LOCALE_RE.test(locale)) {
-            return output(fail(`invalid locale: ${JSON.stringify(locale)} — expected BCP-47 like en or es-CL`));
+            return output(
+              fail(`invalid locale: ${JSON.stringify(locale)} — expected BCP-47 like en or es-CL`),
+            );
           }
           const current = readConfig();
           const next: ToolkitConfig = {
@@ -339,18 +466,24 @@ export function createRepoTools(runtime: RepoRuntime = defaultRuntime) {
             },
           };
           writeConfig(next);
-          return output(ok({ action: "config", path: path.join(configDir(), "config.json"), ...next }));
+          return output(
+            ok({ action: "config", path: path.join(configDir(), "config.json"), ...next }),
+          );
         }
-        const env = Object.fromEntries(Object.entries({
-          WORKFLOW_YT_BASE_URL: base_url,
-          WORKFLOW_YT_MENTION: default_mention,
-          WORKFLOW_YT_MEETING_ISSUE: meeting_issue,
-          WORKFLOW_VCS_PROVIDER: vcs_provider,
-          WORKFLOW_VCS_TARGET_BRANCH: vcs_target_branch,
-        }).filter((entry): entry is [string, string] => entry[1] !== undefined));
-        return output(legacyScriptResult(runtime.runScript(
-          context.directory, "init/apply.sh", [action, "true"], env,
-        )));
+        const env = Object.fromEntries(
+          Object.entries({
+            WORKFLOW_YT_BASE_URL: base_url,
+            WORKFLOW_YT_MENTION: default_mention,
+            WORKFLOW_YT_MEETING_ISSUE: meeting_issue,
+            WORKFLOW_VCS_PROVIDER: vcs_provider,
+            WORKFLOW_VCS_TARGET_BRANCH: vcs_target_branch,
+          }).filter((entry): entry is [string, string] => entry[1] !== undefined),
+        );
+        return output(
+          legacyScriptResult(
+            runtime.runScript(context.directory, "init/apply.sh", [action, "true"], env),
+          ),
+        );
       },
     }),
   };