@brainervirus/workit-core 0.6.0 → 0.7.0

package/src/tools/repo.ts

@@ -1,357 +0,0 @@
-import path from "node:path";
-import { realpathSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { tool, type ToolContext } from "@opencode-ai/plugin";
-import { fail, gitRevisionParts, ok, resolveInside, run } from "../core";
-import { changelogApply } from "../core/changelog";
-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 { ensureProjectGitignore } from "../core/gitignore";
-import { ensureHygieneFiles } from "../core/hygiene";
-
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-const scripts = path.join(packageRoot, "scripts");
-type RunResult = ReturnType<typeof run>;
-
-export type RepoRuntime = {
-  runScript(root: string, script: string, args: string[], env?: Record<string, string>): RunResult;
-  git(root: string, args: string[]): RunResult;
-};
-
-const defaultRuntime: RepoRuntime = {
-  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"));
-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));
-  }
-  try {
-    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));
-  }
-}
-
-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),
-  );
-  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; }
-};
-const sections = (stdout: string) => parseSections(stdout) as Record<string, string>;
-export const normalizeLegacyResult = (value: Record<string, unknown>) => {
-  if (value.error) return fail(String(value.error));
-  if (value.ok === false) return fail("legacy operation reported failure");
-  const { ok: _legacyOk, ...data } = value;
-  return ok(data);
-};
-
-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",
-  ]);
-  return {
-    ...repo,
-    commits: part.Commits ?? "",
-    diff_stat: part["Diff Stat"] ?? "",
-    files: part["Changed Files"] ?? "",
-    pr_template: part["PR Template"] ?? "",
-    vcs_config: optionalJson(part["VCS Config"]),
-    merged_pr_style: optionalJson(part["Merged PR Style"]),
-  };
-};
-
-const parseChangelog = (stdout: string) => {
-  const part = sections(stdout);
-  const repo = parseKeyValueLines(part.Repository ?? "", ["branch", "range"]);
-  return {
-    ...repo,
-    changelog_excerpt: part["Existing CHANGELOG.md"] ?? "",
-    rules: part["Keep a Changelog Rules"] ?? "",
-    commits: part.Commits ?? "",
-    diff_stat: part["Diff Stat"] ?? "",
-    files: part["Changed Files"] ?? "",
-  };
-};
-
-const parseRelease = (stdout: string) => {
-  const part = sections(stdout);
-  const repo = parseKeyValueLines(part.Repository ?? "", ["requested", "range"]);
-  return {
-    ...repo,
-    tags: part.Tags ?? "",
-    commits: part.Commits ?? "",
-    diff_stat: part["Diff Stat"] ?? "",
-    files: part["Changed Files"] ?? "",
-    release_files: part["Existing Release Files"] ?? "",
-  };
-};
-
-const parseDocs = (stdout: string) => {
-  const part = sections(stdout);
-  const repo = parseKeyValueLines(part.Repository ?? "", ["branch", "range"]);
-  return {
-    ...repo,
-    changed_files: part["Changed Files"] ?? "",
-    readme_preview: part["README Preview"] ?? "",
-    package_scripts: part["Package Scripts"] ?? "",
-    files: part["Documentation Files"] ?? "",
-  };
-};
-
-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}`]);
-      if (resolved.exitCode !== 0) throw new Error(`invalid Git revision or range: ${value}`);
-    }
-  };
-  const contextWithRange = (
-    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")); }
-    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));
-
-  return {
-    workflow_toolkit_init_status: tool({
-      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),
-    }),
-    workflow_git_context: tool({
-      description: "Read Git branch and change context",
-      args: { paths: tool.schema.array(tool.schema.string()).optional() },
-      execute: async ({ paths }, context) => output(ok(gitContext(context.directory, paths ?? []))),
-    }),
-    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,
-      )),
-    }),
-    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),
-    }),
-    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),
-    }),
-    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),
-    }),
-    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,
-      )),
-    }),
-    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(),
-        path: tool.schema.string().optional(),
-        normalize_only: tool.schema.boolean().optional(),
-      },
-      execute: async ({ confirmed, entries, path: changelogPath, normalize_only }, context) => {
-        const rejected = requireConfirmed(confirmed);
-        if (rejected) return rejected;
-        try {
-          changelogPath = resolveInside(context.directory, changelogPath ?? "CHANGELOG.md");
-        } 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>));
-      },
-    }),
-    workflow_branch_setup: tool({
-      description: "Apply a confirmed in-place feature or bugfix branch setup",
-      args: {
-        confirmed: tool.schema.boolean(),
-        action: tool.schema.enum(["setup", "reapply_stash"]).optional(),
-        sdd_dir: tool.schema.string().optional(),
-        target_branch: tool.schema.string().optional(),
-        stash: tool.schema.enum(["yes", "no"]).optional(),
-      },
-      execute: async ({ confirmed, action, sdd_dir, target_branch, stash }, context) => {
-        const rejected = requireConfirmed(confirmed);
-        if (rejected) return rejected;
-        let resolvedSdd = sdd_dir ?? "docs";
-        try {
-          resolvedSdd = resolveInside(context.directory, resolvedSdd);
-        } catch (error) {
-          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,
-        });
-        return output(legacyScriptResult({
-          stdout: JSON.stringify(result),
-          stderr: "",
-          exitCode: result.error ? 1 : 0,
-          cwd: context.directory,
-        }));
-      },
-    }),
-    workflow_commit: tool({
-      description: "Commit the current index on a feature or bugfix branch without staging files",
-      args: { confirmed: tool.schema.boolean(), message: tool.schema.string() },
-      execute: async ({ confirmed, message }, context) => {
-        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),
-        ));
-        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() })));
-      },
-    }),
-    workflow_pr_create: tool({
-      description: "Create a confirmed pull or merge request",
-      args: {
-        confirmed: tool.schema.boolean(),
-        title: tool.schema.string(),
-        body: tool.schema.string().optional(),
-        draft: tool.schema.boolean().optional(),
-        target_branch: tool.schema.string().optional(),
-      },
-      execute: async ({ confirmed, title, body, draft, target_branch }, context) => {
-        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),
-        ));
-        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 ?? "",
-        })));
-      },
-    }),
-    workflow_toolkit_init_apply: tool({
-      description: "Apply a confirmed toolkit initialization action",
-      args: {
-        confirmed: tool.schema.boolean(),
-        action: tool.schema.enum([
-          "youtrack_scaffold", "youtrack_json", "youtrack_token_placeholder", "vcs_scaffold", "config", "gitignore", "hygiene",
-        ]),
-        base_url: tool.schema.string().optional(),
-        default_mention: tool.schema.string().optional(),
-        meeting_issue: tool.schema.string().optional(),
-        vcs_provider: tool.schema.enum(["gitlab", "github"]).optional(),
-        vcs_target_branch: tool.schema.string().optional(),
-        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_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) => {
-        const rejected = requireConfirmed(confirmed);
-        if (rejected) return rejected;
-        if (action === "hygiene") {
-          const result = ensureHygieneFiles(context.directory, { confirmed, includeOpenSource: include_open_source });
-          return output(result.ok ? ok(result) : fail(result.error));
-        }
-        if (action === "gitignore") {
-          const result = ensureProjectGitignore(context.directory, confirmed);
-          return output(result.ok ? ok(result) : fail(result.error));
-        }
-        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`));
-          }
-          const current = readConfig();
-          const next: ToolkitConfig = {
-            locale: locale ?? current.locale,
-            localeOptions: locale_options ?? current.localeOptions,
-            timezone: timezone ?? current.timezone,
-            branchPolicy: {
-              preset: (branch_policy_preset as BranchPreset) ?? current.branchPolicy.preset,
-              allowed: branch_policy_allowed ?? current.branchPolicy.allowed,
-              protected: branch_policy_protected ?? current.branchPolicy.protected,
-            },
-          };
-          writeConfig(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,
-        )));
-      },
-    }),
-  };
-}

package/src/tools/rules.ts

@@ -1,30 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { fail, ok } from "../core";
-import { listRules, writeRule, type CanonicalRule } from "../core/rules";
-
-const output = (value: unknown) => JSON.stringify(value, null, 2);
-
-export function createRuleTools() {
-  return {
-    workflow_rule_list: tool({
-      description: "List canonical rules (config) with platforms and source",
-      args: {},
-      execute: async () => output(ok({ rules: listRules() })),
-    }),
-    workflow_rule_edit: tool({
-      description: "Write a canonical rule to the toolkit config dir (agent-assisted)",
-      args: {
-        name: tool.schema.string(),
-        description: tool.schema.string(),
-        platforms: tool.schema.array(tool.schema.enum(["cursor", "opencode"])),
-        body: tool.schema.string(),
-        confirmed: tool.schema.boolean(),
-      },
-      execute: async ({ name, description, platforms, body, confirmed }) => {
-        const rule: CanonicalRule = { name, description, platforms, body };
-        const result = writeRule(rule, confirmed);
-        return output(result.ok ? ok(result) : fail(result.error));
-      },
-    }),
-  };
-}

package/src/tools/sdd.ts

@@ -1,189 +0,0 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { tool, type ToolContext } from "@opencode-ai/plugin";
-import { fail, ok, resolveGitRevision, resolveInside } from "../core";
-import { resolveBranch, docsBranch } from "../core/branch";
-import { docsValidate } from "../core/docs-validate";
-import { parsePlanTasks, resolveHandoffBranch } from "../core/plan-tasks";
-import {
-  sddAppendProgress, sddContext, sddReviewPackage, sddTaskBrief,
-} from "../core/sdd";
-import { WorkflowStateStore } from "../state";
-
-const output = (value: unknown) => JSON.stringify(value, null, 2);
-const requireConfirmed = (confirmed: boolean) => confirmed === true
-  ? null
-  : output(fail("confirmed: true required"));
-
-const relativePath = (root: string, candidate: string) => {
-  if (path.isAbsolute(candidate)) throw new Error("path must be repository-relative");
-  resolveInside(root, candidate);
-  return candidate;
-};
-
-const normalize = (value: Record<string, unknown>) => {
-  if (value.error) return fail(String(value.error));
-  if (value.ok === false) return fail("legacy operation reported failure");
-  const { ok: _legacyOk, ...data } = value;
-  return ok(data);
-};
-
-const invoke = (operation: () => Record<string, unknown>) => {
-  try {
-    return output(normalize(operation()));
-  } catch (error) {
-    return output(fail(error instanceof Error ? error.message : "workflow operation failed"));
-  }
-};
-
-const planPaths = (root: string, planPath: string, suppliedSpecPath?: string) => {
-  const resolved = resolveInside(root, planPath);
-  const match = readFileSync(resolved, "utf8").match(/^\*\*Spec:\*\*\s*(?:`([^`]+)`|(\S+))/m);
-  const spec_path = suppliedSpecPath ?? match?.[1] ?? match?.[2] ?? "";
-  if (spec_path) relativePath(root, spec_path);
-  return {
-    spec_path,
-    plan_path: planPath,
-    sdd_dir: path.posix.join("docs", path.basename(path.dirname(planPath)), "sdd"),
-  };
-};
-
-export function createSddTools(state: WorkflowStateStore) {
-  const record = (context: ToolContext, data: Record<string, unknown>) => state.set(context.sessionID, {
-    spec: String(data.spec_path ?? ""),
-    plan: String(data.plan_path ?? ""),
-    sdd: String(data.sdd_dir ?? ""),
-  });
-
-  return {
-    workflow_docs_branch: tool({
-      description: "Resolve branch for spec/plan authors: keep current feature|bugfix or create from develop",
-      args: {
-        plan_path: tool.schema.string().optional(),
-        kind: tool.schema.enum(["feature", "bugfix"]).optional(),
-      },
-      execute: async ({ plan_path, kind }, context) => invoke(() => {
-        if (plan_path) relativePath(context.directory, plan_path);
-        return docsBranch({
-          plan_path,
-          kind,
-          workspace_root: context.directory,
-        }) as Record<string, unknown>;
-      }),
-    }),
-    workflow_docs_validate: tool({
-      description: "Hard-fail validate spec/plan headers, link, branch, task order; returns quality findings (hard/warning)",
-      args: {
-        spec_path: tool.schema.string(),
-        plan_path: tool.schema.string(),
-      },
-      execute: async ({ spec_path, plan_path }, context) => invoke(() => {
-        relativePath(context.directory, spec_path);
-        relativePath(context.directory, plan_path);
-        const result = docsValidate({
-          spec_path,
-          plan_path,
-          workspace_root: context.directory,
-        }) as Record<string, unknown>;
-        if (result.error) return result;
-        if (result.ok === false) return result;
-        return result;
-      }),
-    }),
-    workflow_plan_tasks: tool({
-      description: "Parse top-level tasks from a workflow plan",
-      args: { plan_path: tool.schema.string(), spec_path: tool.schema.string().optional() },
-      execute: async ({ plan_path, spec_path }, context) => invoke(() => {
-        relativePath(context.directory, plan_path);
-        const paths = planPaths(context.directory, plan_path, spec_path);
-        const parsed = parsePlanTasks(plan_path, context.directory) as Record<string, unknown>;
-        if (parsed.error) return parsed;
-        const branch = paths.spec_path
-          ? resolveHandoffBranch(paths.spec_path, plan_path, context.directory) as Record<string, unknown>
-          : {};
-        if (branch.error) return branch;
-        const data = { ...parsed, ...paths, ...branch };
-        record(context, data);
-        return data;
-      }),
-    }),
-    workflow_resolve_branch: tool({
-      description: "Resolve a branch from repository spec and plan metadata",
-      args: { spec_path: tool.schema.string(), plan_path: tool.schema.string() },
-      execute: async ({ spec_path, plan_path }, context) => invoke(() => {
-        relativePath(context.directory, spec_path);
-        relativePath(context.directory, plan_path);
-        return resolveBranch({ spec_path, plan_path, workspace_root: context.directory });
-      }),
-    }),
-    workflow_sdd_context: tool({
-      description: "Resolve the SDD workspace and progress ledger",
-      args: { plan_path: tool.schema.string() },
-      execute: async ({ plan_path }, context) => invoke(() => {
-        relativePath(context.directory, plan_path);
-        const parsed = sddContext({ slug: undefined, plan_path, workspace_root: context.directory }) as Record<string, unknown>;
-        if (parsed.error) return parsed;
-        const todos = Array.isArray(parsed.todos)
-          ? parsed.todos.map((todo: Record<string, unknown>) => todo.status === "in_progress"
-            ? { ...todo, status: "pending" }
-            : todo)
-          : [];
-        const data = { ...parsed, todos, ...planPaths(context.directory, plan_path), sdd_dir: parsed.sdd_dir };
-        record(context, data);
-        return data;
-      }),
-    }),
-    workflow_sdd_task_brief: tool({
-      description: "Write a confirmed task brief",
-      args: {
-        confirmed: tool.schema.boolean(),
-        sdd_dir: tool.schema.string(),
-        task_id: tool.schema.number(),
-        section_text: tool.schema.string(),
-      },
-      execute: async ({ confirmed, sdd_dir, task_id, section_text }, context) => {
-        const rejected = requireConfirmed(confirmed);
-        if (rejected) return rejected;
-        return invoke(() => {
-          relativePath(context.directory, sdd_dir);
-          return sddTaskBrief({ sdd_dir, task_id, section_text, workspace_root: context.directory });
-        });
-      },
-    }),
-    workflow_sdd_review_package: tool({
-      description: "Write a confirmed task review diff",
-      args: {
-        confirmed: tool.schema.boolean(),
-        sdd_dir: tool.schema.string(),
-        base_sha: tool.schema.string(),
-        head_sha: tool.schema.string(),
-      },
-      execute: async ({ confirmed, sdd_dir, base_sha, head_sha }, context) => {
-        const rejected = requireConfirmed(confirmed);
-        if (rejected) return rejected;
-        return invoke(() => {
-          relativePath(context.directory, sdd_dir);
-          resolveGitRevision(context.directory, base_sha);
-          resolveGitRevision(context.directory, head_sha);
-          return sddReviewPackage({ sdd_dir, base_sha, head_sha, workspace_root: context.directory });
-        });
-      },
-    }),
-    workflow_sdd_append_progress: tool({
-      description: "Append one confirmed validated SDD progress line",
-      args: {
-        confirmed: tool.schema.boolean(),
-        progress_path: tool.schema.string(),
-        line: tool.schema.string(),
-      },
-      execute: async ({ confirmed, progress_path, line }, context) => {
-        const rejected = requireConfirmed(confirmed);
-        if (rejected) return rejected;
-        return invoke(() => {
-          relativePath(context.directory, progress_path);
-          return sddAppendProgress({ progress_path, line, workspace_root: context.directory });
-        });
-      },
-    }),
-  };
-}

package/src/tools/templates.ts

@@ -1,27 +0,0 @@
-import { tool } from "@opencode-ai/plugin";
-import { fail, ok } from "../core";
-import { listTemplates, writeTemplate, type TemplateName } from "../core/templates";
-
-const output = (value: unknown) => JSON.stringify(value, null, 2);
-
-export function createTemplateTools() {
-  return {
-    workflow_template_list: tool({
-      description: "List editable templates (issue-update, greeting, headers) with their source",
-      args: {},
-      execute: async () => output(ok({ templates: listTemplates() })),
-    }),
-    workflow_template_edit: tool({
-      description: "Write an edited template to the toolkit config dir (agent-assisted)",
-      args: {
-        name: tool.schema.enum(["issue-update", "greeting", "headers"]),
-        content: tool.schema.string(),
-        confirmed: tool.schema.boolean(),
-      },
-      execute: async ({ name, content, confirmed }) => {
-        const result = writeTemplate(name as TemplateName, content, confirmed);
-        return output(result.ok ? ok(result) : fail(result.error));
-      },
-    }),
-  };
-}