techunter 0.1.0

package/dist/mcp.js

@@ -0,0 +1,2195 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/github.ts
+var github_exports = {};
+__export(github_exports, {
+  acceptTask: () => acceptTask,
+  claimTask: () => claimTask,
+  closeTask: () => closeTask,
+  createPR: () => createPR,
+  createTask: () => createTask,
+  ensureLabels: () => ensureLabels,
+  formatGuideAsMarkdown: () => formatGuideAsMarkdown,
+  getAuthenticatedUser: () => getAuthenticatedUser,
+  getBaseBranch: () => getBaseBranch,
+  getDefaultBranch: () => getDefaultBranch,
+  getTask: () => getTask,
+  listComments: () => listComments,
+  listMyTasks: () => listMyTasks,
+  listTasks: () => listTasks,
+  listTasksForReview: () => listTasksForReview,
+  markInReview: () => markInReview,
+  postComment: () => postComment,
+  postGuideComment: () => postGuideComment,
+  rejectTask: () => rejectTask
+});
+import { Octokit } from "@octokit/rest";
+function createOctokit(token) {
+  return new Octokit({
+    auth: token,
+    log: { debug: () => {
+    }, info: () => {
+    }, warn: () => {
+    }, error: () => {
+    } }
+  });
+}
+function parseIssue(issue) {
+  return {
+    number: issue.number,
+    title: issue.title,
+    body: issue.body ?? null,
+    state: issue.state,
+    assignee: issue.assignee?.login ?? null,
+    labels: (issue.labels ?? []).map(
+      (l) => typeof l === "string" ? l : l.name ?? ""
+    ),
+    htmlUrl: issue.html_url
+  };
+}
+async function listTasks(config) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const [available, claimed, inReview, changesNeeded] = await Promise.all([
+    octokit.issues.listForRepo({
+      owner,
+      repo,
+      labels: LABEL_AVAILABLE,
+      state: "open",
+      per_page: 50
+    }),
+    octokit.issues.listForRepo({
+      owner,
+      repo,
+      labels: LABEL_CLAIMED,
+      state: "open",
+      per_page: 50
+    }),
+    octokit.issues.listForRepo({
+      owner,
+      repo,
+      labels: LABEL_IN_REVIEW,
+      state: "open",
+      per_page: 50
+    }),
+    octokit.issues.listForRepo({
+      owner,
+      repo,
+      labels: LABEL_CHANGES_NEEDED,
+      state: "open",
+      per_page: 50
+    })
+  ]);
+  const allIssues = [...available.data, ...claimed.data, ...inReview.data, ...changesNeeded.data];
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const issue of allIssues) {
+    if (!seen.has(issue.number)) {
+      seen.add(issue.number);
+      unique.push(parseIssue(issue));
+    }
+  }
+  return unique.sort((a, b) => a.number - b.number);
+}
+async function getTask(config, number) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.issues.get({ owner, repo, issue_number: number });
+  return parseIssue(data);
+}
+async function createTask(config, title, body) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  await ensureLabels(config);
+  const { data } = await octokit.issues.create({
+    owner,
+    repo,
+    title,
+    body,
+    labels: [LABEL_AVAILABLE]
+  });
+  return parseIssue(data);
+}
+async function claimTask(config, number, username) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  await octokit.issues.update({
+    owner,
+    repo,
+    issue_number: number,
+    assignees: [username]
+  });
+  try {
+    await octokit.issues.removeLabel({
+      owner,
+      repo,
+      issue_number: number,
+      name: LABEL_AVAILABLE
+    });
+  } catch {
+  }
+  await octokit.issues.addLabels({
+    owner,
+    repo,
+    issue_number: number,
+    labels: [LABEL_CLAIMED]
+  });
+}
+function formatGuideAsMarkdown(guide, issueNumber) {
+  const lines = [
+    `## Task Guide \u2014 #${issueNumber}`,
+    "",
+    `> ${guide.summary}`,
+    ""
+  ];
+  if (guide.acceptanceCriteria.length > 0) {
+    lines.push("### Must Deliver");
+    for (const item of guide.acceptanceCriteria) lines.push(`- [ ] ${item}`);
+    lines.push("");
+  }
+  if (guide.filesToModify.length > 0) {
+    lines.push("### Files");
+    for (const file of guide.filesToModify) lines.push(`- \`${file}\``);
+    lines.push("");
+  }
+  if (guide.suggestedSteps.length > 0) {
+    lines.push("<details><summary>Implementation steps</summary>");
+    lines.push("");
+    guide.suggestedSteps.forEach((step, i) => lines.push(`${i + 1}. ${step}`));
+    lines.push("</details>");
+    lines.push("");
+  }
+  if (guide.optionalImprovements.length > 0) {
+    lines.push("### Optional Improvements");
+    for (const item of guide.optionalImprovements) lines.push(`- ${item}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("*Generated by Techunter*");
+  return lines.join("\n");
+}
+async function postComment(config, number, body) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  await octokit.issues.createComment({ owner, repo, issue_number: number, body });
+}
+async function postGuideComment(config, number, guide) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const body = formatGuideAsMarkdown(guide, number);
+  await octokit.issues.createComment({
+    owner,
+    repo,
+    issue_number: number,
+    body
+  });
+}
+async function createPR(config, title, body, branch, base) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.pulls.create({
+    owner,
+    repo,
+    title,
+    body,
+    head: branch,
+    base
+  });
+  return data.html_url;
+}
+async function markInReview(config, number) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  try {
+    await octokit.issues.removeLabel({
+      owner,
+      repo,
+      issue_number: number,
+      name: LABEL_CLAIMED
+    });
+  } catch {
+  }
+  await octokit.issues.addLabels({
+    owner,
+    repo,
+    issue_number: number,
+    labels: [LABEL_IN_REVIEW]
+  });
+}
+async function closeTask(config, number) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data: issue } = await octokit.issues.get({ owner, repo, issue_number: number });
+  const techunterLabels = issue.labels.map((l) => l.name ?? "").filter((l) => [LABEL_AVAILABLE, LABEL_CLAIMED, LABEL_IN_REVIEW, LABEL_CHANGES_NEEDED].includes(l));
+  await octokit.issues.update({ owner, repo, issue_number: number, state: "closed" });
+  for (const label of techunterLabels) {
+    await octokit.issues.removeLabel({ owner, repo, issue_number: number, name: label });
+  }
+}
+async function listComments(config, number, limit = 5) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.issues.listComments({
+    owner,
+    repo,
+    issue_number: number,
+    per_page: 100
+  });
+  return data.slice(-limit).map((c) => ({
+    id: c.id,
+    author: c.user?.login ?? "unknown",
+    body: c.body ?? "",
+    createdAt: c.created_at
+  }));
+}
+async function getAuthenticatedUser(config) {
+  const octokit = createOctokit(config.githubToken);
+  const { data } = await octokit.users.getAuthenticated();
+  return data.login;
+}
+async function listMyTasks(config, username) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.issues.listForRepo({
+    owner,
+    repo,
+    assignee: username,
+    state: "open",
+    per_page: 50
+  });
+  return data.filter(
+    (issue) => issue.labels.some(
+      (l) => l.name === LABEL_CLAIMED || l.name === LABEL_IN_REVIEW || l.name === LABEL_CHANGES_NEEDED
+    )
+  ).map(parseIssue);
+}
+async function listTasksForReview(config, username) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.issues.listForRepo({
+    owner,
+    repo,
+    creator: username,
+    labels: LABEL_IN_REVIEW,
+    state: "open",
+    per_page: 50
+  });
+  return data.map(parseIssue).sort((a, b) => a.number - b.number);
+}
+async function rejectTask(config, number) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  try {
+    await octokit.issues.removeLabel({
+      owner,
+      repo,
+      issue_number: number,
+      name: LABEL_IN_REVIEW
+    });
+  } catch {
+  }
+  await octokit.issues.addLabels({
+    owner,
+    repo,
+    issue_number: number,
+    labels: [LABEL_CHANGES_NEEDED]
+  });
+}
+async function ensureLabels(config) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data: existing } = await octokit.issues.listLabelsForRepo({ owner, repo, per_page: 100 });
+  const existingNames = new Set(existing.map((l) => l.name));
+  await Promise.all(
+    LABELS.filter((label) => !existingNames.has(label.name)).map(
+      (label) => octokit.issues.createLabel({ owner, repo, name: label.name, color: label.color, description: label.description }).catch(() => {
+      })
+    )
+  );
+}
+async function getDefaultBranch(config) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data } = await octokit.repos.get({ owner, repo });
+  return data.default_branch;
+}
+function getBaseBranch(config) {
+  if (config.github.baseBranch) return Promise.resolve(config.github.baseBranch);
+  return getDefaultBranch(config);
+}
+async function acceptTask(config, issueNumber) {
+  const octokit = createOctokit(config.githubToken);
+  const { owner, repo } = config.github;
+  const { data: prs } = await octokit.pulls.list({ owner, repo, state: "open", per_page: 100 });
+  const pr = prs.find((p) => p.head.ref.startsWith(`task-${issueNumber}-`));
+  if (!pr) throw new Error(`No open PR found for task #${issueNumber} (expected branch starting with task-${issueNumber}-)`);
+  const { data: merge } = await octokit.pulls.merge({
+    owner,
+    repo,
+    pull_number: pr.number,
+    merge_method: "merge"
+  });
+  await closeTask(config, issueNumber);
+  return { prNumber: pr.number, prUrl: pr.html_url, sha: merge.sha ?? "" };
+}
+var LABEL_AVAILABLE, LABEL_CLAIMED, LABEL_IN_REVIEW, LABEL_CHANGES_NEEDED, LABELS;
+var init_github = __esm({
+  "src/lib/github.ts"() {
+    "use strict";
+    LABEL_AVAILABLE = "techunter:available";
+    LABEL_CLAIMED = "techunter:claimed";
+    LABEL_IN_REVIEW = "techunter:in-review";
+    LABEL_CHANGES_NEEDED = "techunter:changes-needed";
+    LABELS = [
+      { name: LABEL_AVAILABLE, color: "0e8a16", description: "Task available to claim" },
+      { name: LABEL_CLAIMED, color: "e4a000", description: "Task claimed by a developer" },
+      { name: LABEL_IN_REVIEW, color: "0075ca", description: "Task submitted for review" },
+      { name: LABEL_CHANGES_NEEDED, color: "e11d48", description: "Task needs changes" }
+    ];
+  }
+});
+
+// src/mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/pick/index.ts
+var pick_exports = {};
+__export(pick_exports, {
+  definition: () => definition3,
+  execute: () => execute3,
+  run: () => run3,
+  terminal: () => terminal3
+});
+init_github();
+import chalk6 from "chalk";
+import ora3 from "ora";
+import { select as select3 } from "@inquirer/prompts";
+
+// src/lib/git.ts
+import chalk from "chalk";
+import { simpleGit } from "simple-git";
+var git = simpleGit();
+async function getCurrentBranch() {
+  const summary = await git.branch();
+  return summary.current;
+}
+async function createAndSwitchBranch(name) {
+  await git.checkoutLocalBranch(name);
+}
+async function pushBranch(name) {
+  await git.push("origin", name, ["--set-upstream"]);
+}
+function makeBranchName(issueNumber, username) {
+  const slug = username.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "user";
+  return `task-${issueNumber}-${slug}`;
+}
+async function findMergeBase(configuredBase) {
+  const candidates = configuredBase ? [`origin/${configuredBase}`, "origin/main", "origin/master"] : ["origin/main", "origin/master"];
+  const unique = [...new Set(candidates)];
+  for (const base of unique) {
+    try {
+      const result = await git.raw(["merge-base", "HEAD", base]);
+      return result.trim();
+    } catch {
+    }
+  }
+  return null;
+}
+async function getDiff(baseBranch) {
+  const status = await git.status();
+  const parts = [];
+  const fileLines = [
+    ...status.modified.map((f) => `  M  ${f}`),
+    ...status.created.map((f) => `  A  ${f}`),
+    ...status.deleted.map((f) => `  D  ${f}`),
+    ...status.renamed.map((f) => `  R  ${f.from} \u2192 ${f.to}`),
+    ...status.not_added.map((f) => `  ?  ${f}`)
+  ];
+  if (fileLines.length > 0) {
+    parts.push("## Uncommitted changes\n" + fileLines.join("\n"));
+    const uncommitted = await git.diff(["HEAD"]);
+    if (uncommitted) {
+      const capped = uncommitted.length > 8e3 ? uncommitted.slice(0, 8e3) + "\n... (truncated)" : uncommitted;
+      parts.push("## Uncommitted diff\n```diff\n" + capped + "\n```");
+    }
+  }
+  const mergeBase = await findMergeBase(baseBranch);
+  if (mergeBase) {
+    const log = await git.log({ from: mergeBase, to: "HEAD" });
+    if (log.total > 0) {
+      const logLines = log.all.map((c) => `  ${c.hash.slice(0, 7)}  ${c.message}`);
+      parts.push(`## Branch commits (${log.total} total)
+` + logLines.join("\n"));
+      const branchDiff = await git.diff([mergeBase, "HEAD"]);
+      if (branchDiff) {
+        const capped = branchDiff.length > 12e3 ? branchDiff.slice(0, 12e3) + "\n... (truncated)" : branchDiff;
+        parts.push("## Full branch diff vs main\n```diff\n" + capped + "\n```");
+      }
+    }
+  }
+  return parts.length > 0 ? parts.join("\n\n") : "No changes detected.";
+}
+async function stageAllAndCommit(message) {
+  const status = await git.status();
+  if (!status.isClean()) {
+    await git.add(".");
+    await git.commit(message);
+  } else {
+    console.log(chalk.dim("  Working tree clean \u2014 no new commit created, pushing existing commits."));
+  }
+  const branch = (await git.branch()).current;
+  await git.push("origin", branch, ["--set-upstream"]);
+}
+
+// src/lib/markdown.ts
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+marked.use(markedTerminal({ showSectionPrefix: false }));
+function renderMarkdown(text) {
+  return marked(text);
+}
+
+// src/lib/display.ts
+init_github();
+import chalk2 from "chalk";
+var LABEL_AVAILABLE2 = "techunter:available";
+var LABEL_CLAIMED2 = "techunter:claimed";
+var LABEL_IN_REVIEW2 = "techunter:in-review";
+var LABEL_CHANGES_NEEDED2 = "techunter:changes-needed";
+function getStatus(issue) {
+  if (issue.labels.includes(LABEL_CHANGES_NEEDED2)) return "changes-needed";
+  if (issue.labels.includes(LABEL_IN_REVIEW2)) return "in-review";
+  if (issue.labels.includes(LABEL_CLAIMED2)) return "claimed";
+  if (issue.labels.includes(LABEL_AVAILABLE2)) return "available";
+  return "unknown";
+}
+function colorStatus(status) {
+  const padded = status.padEnd(14);
+  switch (status) {
+    case "available":
+      return chalk2.green(padded);
+    case "claimed":
+      return chalk2.yellow(padded);
+    case "in-review":
+      return chalk2.blue(padded);
+    case "changes-needed":
+      return chalk2.red(padded);
+    default:
+      return padded;
+  }
+}
+function printTaskDetail(issue) {
+  const divider = chalk2.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  console.log(
+    chalk2.bold(` #${issue.number}`) + "  " + colorStatus(getStatus(issue)) + "  " + chalk2.dim(issue.assignee ? `@${issue.assignee}` : "\u2014")
+  );
+  console.log(chalk2.bold("\n " + issue.title));
+  if (issue.body) {
+    console.log("");
+    console.log(renderMarkdown(issue.body));
+  }
+  console.log("\n " + chalk2.dim(issue.htmlUrl));
+  console.log(divider + "\n");
+}
+async function printTaskList(config) {
+  try {
+    const tasks = await listTasks(config);
+    const divider = chalk2.dim("\u2500".repeat(70));
+    console.log("");
+    console.log(chalk2.dim(" " + "#".padEnd(5) + "Status".padEnd(14) + "Assignee".padEnd(16) + "Title"));
+    console.log(divider);
+    if (tasks.length === 0) {
+      console.log(chalk2.dim("  (no tasks)"));
+    } else {
+      for (const t of tasks) {
+        const num = `#${t.number}`.padEnd(5);
+        const status = colorStatus(getStatus(t));
+        const assignee = (t.assignee ? `@${t.assignee}` : "\u2014").padEnd(16);
+        const title = t.title.length > 36 ? t.title.slice(0, 33) + "..." : t.title;
+        console.log(` ${num}${status}${assignee}${title}`);
+      }
+    }
+    console.log(divider);
+    return tasks;
+  } catch (err) {
+    console.log(chalk2.yellow(`(Could not load tasks: ${err.message})`));
+    return [];
+  }
+}
+
+// src/lib/launch.ts
+import { spawn } from "child_process";
+import chalk3 from "chalk";
+function buildClaudePrompt(issue, branch) {
+  const lines = [
+    `You are working on task #${issue.number}: ${issue.title}`,
+    `Branch: ${branch}`,
+    ""
+  ];
+  if (issue.body) lines.push(issue.body.trim(), "");
+  lines.push(
+    "Implement the task. A detailed guide has been posted as a comment on the GitHub issue.",
+    "When done, return to tch and run /submit to review and deliver."
+  );
+  return lines.join("\n");
+}
+async function launchClaudeCode(issue, branch) {
+  const prompt = buildClaudePrompt(issue, branch);
+  console.log(chalk3.dim("\n  Launching Claude Code\u2026\n"));
+  await new Promise((resolve) => {
+    const child = spawn("claude", [prompt], { stdio: "inherit", shell: true });
+    child.on("close", () => resolve());
+    child.on("error", () => {
+      console.log(
+        chalk3.yellow(
+          "  Could not launch claude. Make sure Claude Code is installed:\n  npm install -g @anthropic-ai/claude-code"
+        )
+      );
+      resolve();
+    });
+  });
+}
+
+// src/tools/submit/index.ts
+var submit_exports = {};
+__export(submit_exports, {
+  definition: () => definition,
+  execute: () => execute,
+  run: () => run,
+  terminal: () => terminal
+});
+init_github();
+import chalk5 from "chalk";
+import ora from "ora";
+import { select, input as promptInput } from "@inquirer/prompts";
+
+// src/lib/client.ts
+import OpenAI from "openai";
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_MODEL = "z-ai/glm-5";
+function createClient(config) {
+  return new OpenAI({
+    baseURL: config.aiBaseUrl ?? DEFAULT_BASE_URL,
+    apiKey: config.aiApiKey
+  });
+}
+function getModel(config) {
+  return config.aiModel ?? DEFAULT_MODEL;
+}
+
+// src/lib/agent-ui.ts
+import chalk4 from "chalk";
+function formatInput(input) {
+  return Object.entries(input).map(([k, v]) => {
+    if (typeof v === "number") return `${k}=${v}`;
+    if (typeof v === "string") {
+      if (k === "body" || v.length > 50) return `${k}=[${v.length} chars]`;
+      return `${k}="${v}"`;
+    }
+    return `${k}=${JSON.stringify(v)}`;
+  }).join("  ");
+}
+function summarize(result) {
+  const first = result.split("\n").find((l) => l.trim()) ?? result;
+  return first.length > 100 ? first.slice(0, 97) + "..." : first;
+}
+function printToolCall(name, input) {
+  const params = formatInput(input);
+  console.log(`  ${chalk4.cyan("\u2192")} ${chalk4.bold(name)}${params ? "  " + chalk4.dim(params) : ""}`);
+}
+function printToolResult(result) {
+  const ok = !result.startsWith("Error:");
+  const icon = ok ? chalk4.green("\u2713") : chalk4.red("\u2717");
+  console.log(`  ${icon} ${chalk4.dim(summarize(result))}`);
+}
+
+// src/lib/sub-agent.ts
+async function runSubAgentLoop(config, systemPrompt, userMessage, toolNames) {
+  const client = createClient(config);
+  const selected = toolModules.filter((m) => toolNames.includes(m.definition.function.name));
+  const tools2 = selected.map((m) => m.definition);
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userMessage }
+  ];
+  const MAX_ITERATIONS = 20;
+  let iterations = 0;
+  for (; ; ) {
+    if (++iterations > MAX_ITERATIONS) {
+      throw new Error(`Sub-agent exceeded ${MAX_ITERATIONS} iterations without finishing.`);
+    }
+    const res = await client.chat.completions.create({ model: getModel(config), tools: tools2, messages });
+    const choice = res.choices[0];
+    messages.push({
+      role: "assistant",
+      content: choice.message.content ?? null,
+      ...choice.message.tool_calls ? { tool_calls: choice.message.tool_calls } : {}
+    });
+    if (choice.finish_reason === "stop") {
+      return choice.message.content ?? "";
+    }
+    if (choice.finish_reason === "tool_calls") {
+      for (const tc of choice.message.tool_calls ?? []) {
+        let input;
+        try {
+          input = JSON.parse(tc.function.arguments);
+        } catch {
+          input = {};
+        }
+        printToolCall(tc.function.name, input);
+        const mod = selected.find((m) => m.definition.function.name === tc.function.name);
+        const result = mod ? await mod.execute(input, config) : `Unknown tool: ${tc.function.name}`;
+        printToolResult(result);
+        messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+      }
+    }
+  }
+}
+
+// src/tools/submit/prompts.ts
+var REVIEWER_SYSTEM_PROMPT = "You are a concise code reviewer. Use run_command to run tests/lint if needed, and read_file to inspect specific files. Then output your review: for each acceptance criterion mark \u2705 met or \u274C not met with a one-line reason. End with an overall verdict line: Ready to submit / Not ready. Reply in the same language as the task.";
+
+// src/tools/submit/reviewer.ts
+async function reviewChanges(config, issueNumber, issue, diff) {
+  return runSubAgentLoop(
+    config,
+    REVIEWER_SYSTEM_PROMPT,
+    `Task #${issueNumber}: ${issue.title}
+
+Acceptance Criteria:
+${issue.body ?? "(none)"}
+
+Diff:
+${diff || "(no changes)"}`,
+    ["run_command", "read_file", "get_diff"]
+  );
+}
+
+// src/tools/submit/index.ts
+var definition = {
+  type: "function",
+  function: {
+    name: "submit",
+    description: "Submit the current task: reviews changes against acceptance criteria, then commits, creates a PR, and marks the issue as in-review. Equivalent to /submit.",
+    parameters: {
+      type: "object",
+      properties: {
+        commit_message: { type: "string", description: 'Commit message (optional \u2014 defaults to "complete: {task title}").' }
+      },
+      required: []
+    }
+  }
+};
+async function run(config) {
+  const branch = await getCurrentBranch();
+  const match = branch.match(/^task-(\d+)-/);
+  if (!match) {
+    return `Not on a task branch (current: ${branch}). Expected format: task-N-title.`;
+  }
+  const issueNumber = parseInt(match[1], 10);
+  let spinner = ora("Loading task and diff\u2026").start();
+  const [issue, defaultBranch, diff] = await Promise.all([
+    getTask(config, issueNumber),
+    getBaseBranch(config),
+    getDiff(config.github.baseBranch)
+  ]);
+  spinner.stop();
+  const reviewSpinner = ora("Reviewing changes\u2026").start();
+  let review = "";
+  try {
+    review = await reviewChanges(config, issueNumber, issue, diff);
+  } catch (err) {
+    review = `(Review failed: ${err.message})`;
+  }
+  reviewSpinner.stop();
+  const divider = chalk5.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  console.log(chalk5.bold(`  Review \u2014 task #${issueNumber} "${issue.title}"`));
+  console.log(divider);
+  console.log(renderMarkdown(review));
+  console.log(divider + "\n");
+  let shouldProceed;
+  try {
+    shouldProceed = await select({
+      message: `Submit task #${issueNumber}?`,
+      choices: [
+        { name: "Yes, submit", value: true },
+        { name: "No, not ready yet", value: false }
+      ]
+    });
+  } catch {
+    return "Submit cancelled.";
+  }
+  if (!shouldProceed) return "Submit cancelled by user.";
+  let commitMessage;
+  try {
+    commitMessage = await promptInput({
+      message: "Commit message:",
+      default: `complete: ${issue.title}`
+    });
+  } catch {
+    return "Submit cancelled.";
+  }
+  if (!commitMessage.trim()) return "Submit cancelled.";
+  spinner = ora("Committing and pushing\u2026").start();
+  try {
+    await stageAllAndCommit(commitMessage.trim());
+    spinner.stop();
+  } catch (err) {
+    spinner.stop();
+    return `Commit failed: ${err.message}`;
+  }
+  spinner = ora("Creating pull request\u2026").start();
+  let prUrl;
+  try {
+    prUrl = await createPR(
+      config,
+      issue.title,
+      `Closes #${issueNumber}
+
+${issue.body ?? ""}`.trim(),
+      branch,
+      defaultBranch
+    );
+    spinner.stop();
+  } catch (err) {
+    spinner.stop();
+    return `Committed but PR creation failed: ${err.message}`;
+  }
+  spinner = ora("Marking as in-review\u2026").start();
+  try {
+    await markInReview(config, issueNumber);
+    spinner.stop();
+  } catch (err) {
+    spinner.stop();
+    return `PR created (${prUrl}) but failed to update label: ${err.message}`;
+  }
+  return `Task #${issueNumber} submitted.
+Commit: "${commitMessage.trim()}"
+PR: ${prUrl}`;
+}
+async function execute(input, config) {
+  const branch = await getCurrentBranch();
+  const match = branch.match(/^task-(\d+)-/);
+  if (!match) return `Not on a task branch (current: ${branch}). Expected format: task-N-title.`;
+  const issueNumber = parseInt(match[1], 10);
+  const [issue, defaultBranch, diff] = await Promise.all([
+    getTask(config, issueNumber),
+    getBaseBranch(config),
+    getDiff(config.github.baseBranch)
+  ]);
+  let review = "";
+  try {
+    review = await reviewChanges(config, issueNumber, issue, diff);
+  } catch (err) {
+    review = `(Review failed: ${err.message})`;
+  }
+  const commitMessage = input["commit_message"]?.trim() || `complete: ${issue.title}`;
+  try {
+    await stageAllAndCommit(commitMessage);
+  } catch (err) {
+    return `Commit failed: ${err.message}`;
+  }
+  let prUrl;
+  try {
+    prUrl = await createPR(
+      config,
+      issue.title,
+      `Closes #${issueNumber}
+
+${issue.body ?? ""}`.trim(),
+      branch,
+      defaultBranch
+    );
+  } catch (err) {
+    return `Committed but PR creation failed: ${err.message}`;
+  }
+  try {
+    await markInReview(config, issueNumber);
+  } catch {
+  }
+  return `Task #${issueNumber} submitted.
+Review:
+${review}
+Commit: "${commitMessage}"
+PR: ${prUrl}`;
+}
+var terminal = true;
+
+// src/tools/close/index.ts
+var close_exports = {};
+__export(close_exports, {
+  definition: () => definition2,
+  execute: () => execute2,
+  run: () => run2,
+  terminal: () => terminal2
+});
+init_github();
+import { select as select2 } from "@inquirer/prompts";
+import ora2 from "ora";
+var definition2 = {
+  type: "function",
+  function: {
+    name: "close",
+    description: "Close a task (GitHub Issue). Equivalent to /close.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "Issue number to close." }
+      },
+      required: ["issue_number"]
+    }
+  }
+};
+async function run2(config, opts = {}) {
+  let issueNumber = opts.issue_number;
+  if (!issueNumber) {
+    let tasks;
+    try {
+      tasks = await listTasks(config);
+    } catch (err) {
+      return `Error loading tasks: ${err.message}`;
+    }
+    if (tasks.length === 0) return "No tasks found.";
+    try {
+      issueNumber = await select2({
+        message: "Select task to close:",
+        choices: tasks.map((t) => ({ name: `#${t.number}  [${getStatus(t)}]  ${t.title}`, value: t.number }))
+      });
+    } catch {
+      return "Cancelled.";
+    }
+  }
+  let confirmed;
+  try {
+    confirmed = await select2({
+      message: `Close task #${issueNumber}?`,
+      choices: [
+        { name: "Yes, close it", value: true },
+        { name: "No, cancel", value: false }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (!confirmed) return "Cancelled.";
+  const spinner = ora2(`Closing #${issueNumber}\u2026`).start();
+  try {
+    await closeTask(config, issueNumber);
+    spinner.stop();
+    return `Task #${issueNumber} closed.`;
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
+  }
+}
+async function execute2(input, config) {
+  const issueNumber = input["issue_number"];
+  const spinner = ora2(`Closing #${issueNumber}\u2026`).start();
+  try {
+    await closeTask(config, issueNumber);
+    spinner.stop();
+    return `Task #${issueNumber} closed.`;
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
+  }
+}
+var terminal2 = true;
+
+// src/tools/pick/index.ts
+var definition3 = {
+  type: "function",
+  function: {
+    name: "pick",
+    description: "Browse the task list and act on a specific task (claim, submit, close, or view). Equivalent to /pick. Use when the user wants to explore or take action on a task.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "Issue number to act on." },
+        action: {
+          type: "string",
+          enum: ["claim", "view"],
+          description: '"claim" to assign yourself and create a branch; "view" to return task details.'
+        }
+      },
+      required: ["issue_number", "action"]
+    }
+  }
+};
+async function run3(config, preselected) {
+  let chosenNumber;
+  if (preselected !== void 0) {
+    chosenNumber = preselected;
+  } else {
+    let tasks;
+    try {
+      tasks = await listTasks(config);
+    } catch (err) {
+      return `Error: ${err.message}`;
+    }
+    if (tasks.length === 0) return "No tasks found.";
+    try {
+      chosenNumber = await select3({
+        message: "Select a task:",
+        choices: tasks.map((t) => ({
+          name: `#${String(t.number).padEnd(4)} ${colorStatus(getStatus(t))} ${t.title}`,
+          value: t.number
+        }))
+      });
+    } catch {
+      return "Cancelled.";
+    }
+  }
+  let issue;
+  try {
+    issue = await getTask(config, chosenNumber);
+  } catch (err) {
+    return `Error loading task: ${err.message}`;
+  }
+  printTaskDetail(issue);
+  const status = getStatus(issue);
+  if (status === "changes-needed") {
+    try {
+      const comments = await listComments(config, issue.number, 1);
+      if (comments.length > 0) {
+        const c = comments[0];
+        const divider = chalk6.dim("\u2500".repeat(70));
+        console.log(
+          chalk6.red.bold("  Latest rejection feedback") + chalk6.dim(` \u2014 @${c.author} \xB7 ${c.createdAt.slice(0, 10)}`)
+        );
+        console.log(divider);
+        console.log(renderMarkdown(c.body));
+        console.log(divider + "\n");
+      }
+    } catch {
+    }
+  }
+  const actions = [];
+  if (status === "available") actions.push({ name: "Claim this task", value: "claim" });
+  if (status === "claimed" || status === "changes-needed") actions.push({ name: "Submit this task", value: "submit" });
+  actions.push({ name: "Close this task", value: "close" });
+  actions.push({ name: "Nothing, just viewing", value: "none" });
+  let action;
+  try {
+    action = await select3({ message: "Action:", choices: actions });
+  } catch {
+    return "Cancelled.";
+  }
+  if (action === "none") return `Viewed task #${issue.number}.`;
+  if (action === "claim") {
+    try {
+      const { getAuthenticatedUser: getAuthenticatedUser2, listMyTasks: listMyTasks2 } = await Promise.resolve().then(() => (init_github(), github_exports));
+      const me = await getAuthenticatedUser2(config);
+      const myTasks = await listMyTasks2(config, me);
+      const activeTask = myTasks.find((t) => {
+        const labels = t.labels;
+        return labels.includes("techunter:claimed") || labels.includes("techunter:changes-needed");
+      });
+      if (activeTask) {
+        return `You already have an active task: #${activeTask.number} "${activeTask.title}"
+Finish or submit it before claiming a new one.`;
+      }
+      let spinner = ora3(`Claiming #${issue.number}\u2026`).start();
+      await claimTask(config, issue.number, me);
+      spinner.stop();
+      const branch = makeBranchName(issue.number, me);
+      spinner = ora3(`Creating branch ${branch}\u2026`).start();
+      try {
+        await createAndSwitchBranch(branch);
+        spinner.stop();
+      } catch {
+        spinner.warn(`Could not create branch ${branch}`);
+      }
+      spinner = ora3("Pushing branch\u2026").start();
+      try {
+        await pushBranch(branch);
+        spinner.stop();
+      } catch {
+        spinner.warn("Could not push branch");
+      }
+      console.log(chalk6.green(`
+  Claimed! Branch: ${branch}
+`));
+      let openClaude;
+      try {
+        openClaude = await select3({
+          message: "Open Claude Code for this task?",
+          choices: [
+            { name: "Yes, start coding now", value: true },
+            { name: "No, return to tch", value: false }
+          ]
+        });
+      } catch {
+        openClaude = false;
+      }
+      if (openClaude) await launchClaudeCode(issue, branch);
+      return `Task #${issue.number} claimed. Branch: ${branch}`;
+    } catch (err) {
+      return `Error claiming task: ${err.message}`;
+    }
+  }
+  if (action === "submit") return run(config);
+  if (action === "close") return run2(config, { issue_number: issue.number });
+  return "Cancelled.";
+}
+async function execute3(input, config) {
+  const issueNumber = input["issue_number"];
+  const action = input["action"];
+  let issue;
+  try {
+    issue = await getTask(config, issueNumber);
+  } catch (err) {
+    return `Error loading task: ${err.message}`;
+  }
+  if (action === "view") {
+    const status = getStatus(issue);
+    const assignee = issue.assignee ? `@${issue.assignee}` : "\u2014";
+    return [`#${issue.number}  [${status}]  ${assignee}  ${issue.title}`, issue.body ?? ""].join("\n\n");
+  }
+  if (action === "claim") {
+    const { getAuthenticatedUser: getAuthenticatedUser2, listMyTasks: listMyTasks2 } = await Promise.resolve().then(() => (init_github(), github_exports));
+    const me = await getAuthenticatedUser2(config);
+    const myTasks = await listMyTasks2(config, me);
+    const activeTask = myTasks.find((t) => {
+      return t.labels.includes("techunter:claimed") || t.labels.includes("techunter:changes-needed");
+    });
+    if (activeTask) {
+      return `You already have an active task: #${activeTask.number} "${activeTask.title}". Finish it before claiming a new one.`;
+    }
+    try {
+      await claimTask(config, issueNumber, me);
+    } catch (err) {
+      return `Error claiming task: ${err.message}`;
+    }
+    const branch = makeBranchName(issueNumber, me);
+    try {
+      await createAndSwitchBranch(branch);
+    } catch {
+    }
+    try {
+      await pushBranch(branch);
+    } catch {
+    }
+    return `Task #${issueNumber} claimed. Branch: ${branch}`;
+  }
+  return `Unknown action: ${action}`;
+}
+var terminal3 = true;
+
+// src/tools/new-task/index.ts
+var new_task_exports = {};
+__export(new_task_exports, {
+  definition: () => definition4,
+  execute: () => execute4,
+  run: () => run4,
+  terminal: () => terminal4
+});
+init_github();
+import { select as select4, input as promptInput2 } from "@inquirer/prompts";
+import { writeFile, readFile, mkdtemp, rm } from "fs/promises";
+import { spawn as spawn2 } from "child_process";
+import { tmpdir } from "os";
+import path from "path";
+import ora4 from "ora";
+import chalk7 from "chalk";
+import open from "open";
+
+// src/tools/new-task/prompts.ts
+var GUIDE_FORMAT = `
+## Guide format
+Write the guide in the same language as the task title. Use plain markdown, no code blocks. Be concise. Include exactly these sections:
+
+### \u4EFB\u52A1\u63CF\u8FF0
+Describe what needs to be done and why. Cover the background, the problem being solved, and the expected outcome. Be as detailed as needed to make the task clear.
+
+### \u6D89\u53CA\u6587\u4EF6
+List each file path with CREATE/MODIFY, and one sentence describing what changes.
+
+### \u8F93\u5165 / \u8F93\u51FA
+What the feature/fix receives as input and what it produces or affects.
+
+### \u9A8C\u6536\u6807\u51C6
+Checkbox list of testable conditions. Keep it short \u2014 3 to 6 items max.
+`.trim();
+
+// src/tools/new-task/guide-generator.ts
+async function generateGuide(config, title, revise) {
+  const userMessage = revise ? `Revise the following implementation guide for task: "${title}"
+
+User feedback: ${revise.feedback}
+
+Previous guide:
+${revise.previousGuide}` : `Write an implementation guide for this task: "${title}"`;
+  return runSubAgentLoop(
+    config,
+    "You are a senior engineer writing a brief task guide for a developer. Use scan_project and read_file to identify which files are relevant. Do NOT include code snippets or implementation details. When you have enough context, write the guide.\n\n" + GUIDE_FORMAT,
+    userMessage,
+    ["scan_project", "read_file", "run_command", "ask_user"]
+  );
+}
+
+// src/tools/new-task/index.ts
+async function openInEditor(content) {
+  const dir = await mkdtemp(path.join(tmpdir(), "tch-guide-"));
+  const file = path.join(dir, "guide.md");
+  try {
+    await writeFile(file, content, "utf-8");
+    const editor = process.env["EDITOR"] ?? process.env["VISUAL"] ?? (process.platform === "win32" ? "notepad" : "vi");
+    await new Promise((resolve, reject) => {
+      const child = spawn2(editor, [file], { stdio: "inherit", shell: true });
+      child.on("exit", (code) => code === 0 ? resolve() : reject(new Error(`Editor exited with code ${code}`)));
+      child.on("error", reject);
+    });
+    return await readFile(file, "utf-8");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+var definition4 = {
+  type: "function",
+  function: {
+    name: "new_task",
+    description: "Create a new task (GitHub Issue): scans the project, generates a full implementation guide, then creates the issue. Equivalent to /new.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Task title." },
+        feedback: { type: "string", description: "Optional feedback to revise the generated guide before creating the issue." }
+      },
+      required: ["title"]
+    }
+  }
+};
+async function run4(config, opts = {}) {
+  let title = opts.title?.trim();
+  if (!title) {
+    try {
+      title = (await promptInput2({ message: "Task title:" })).trim();
+    } catch {
+      return "Cancelled.";
+    }
+    if (!title) return "Cancelled.";
+  }
+  const spinner = ora4("Scanning project and generating guide\u2026").start();
+  let guide;
+  try {
+    guide = await generateGuide(config, title);
+    spinner.stop();
+  } catch (err) {
+    spinner.stop();
+    return `Error generating guide: ${err.message}`;
+  }
+  const divider = chalk7.dim("\u2500".repeat(70));
+  for (; ; ) {
+    console.log("\n" + divider);
+    console.log(chalk7.bold("  Generated guide preview"));
+    console.log(divider);
+    console.log(renderMarkdown(guide));
+    console.log(divider + "\n");
+    let action;
+    try {
+      action = await select4({
+        message: "Create this task?",
+        choices: [
+          { name: "Yes, create task", value: "create" },
+          { name: "Edit in editor", value: "edit" },
+          { name: "Let AI revise", value: "ai" },
+          { name: "Cancel", value: "cancel" }
+        ]
+      });
+    } catch {
+      return "Cancelled.";
+    }
+    if (action === "cancel") return "Cancelled.";
+    if (action === "create") break;
+    if (action === "edit") {
+      try {
+        guide = await openInEditor(guide);
+      } catch (err) {
+        console.log(chalk7.yellow(`  Editor error: ${err.message}`));
+      }
+      continue;
+    }
+    let feedback;
+    try {
+      feedback = (await promptInput2({ message: "What should be changed?" })).trim();
+    } catch {
+      return "Cancelled.";
+    }
+    if (!feedback) continue;
+    const reviseSpinner = ora4("Revising guide\u2026").start();
+    try {
+      guide = await generateGuide(config, title, { feedback, previousGuide: guide });
+      reviseSpinner.stop();
+    } catch (err) {
+      reviseSpinner.stop();
+      console.log(chalk7.yellow(`  Revision error: ${err.message}`));
+    }
+  }
+  const createSpinner = ora4(`Creating "${title}"\u2026`).start();
+  let htmlUrl;
+  let issueNumber;
+  let issueTitle;
+  try {
+    const issue = await createTask(config, title, guide);
+    createSpinner.stop();
+    htmlUrl = issue.htmlUrl;
+    issueNumber = issue.number;
+    issueTitle = issue.title;
+  } catch (err) {
+    createSpinner.stop();
+    return `Error: ${err.message}`;
+  }
+  console.log(chalk7.green(`
+  Created #${issueNumber} "${issueTitle}"
+  ${chalk7.dim(htmlUrl)}
+`));
+  try {
+    const openBrowser = await select4({
+      message: "Open issue in browser?",
+      choices: [
+        { name: "Yes", value: true },
+        { name: "No", value: false }
+      ]
+    });
+    if (openBrowser) await open(htmlUrl);
+  } catch {
+  }
+  return `Created #${issueNumber} "${issueTitle}" \u2014 ${htmlUrl}`;
+}
+async function execute4(input, config) {
+  const title = input["title"].trim();
+  const feedback = input["feedback"];
+  let guide = await generateGuide(config, title);
+  if (feedback) {
+    guide = await generateGuide(config, title, { feedback, previousGuide: guide });
+  }
+  try {
+    const issue = await createTask(config, title, guide);
+    return `Created #${issue.number} "${issue.title}" \u2014 ${issue.htmlUrl}
+
+Guide:
+${guide}`;
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+var terminal4 = true;
+
+// src/tools/my-status/index.ts
+var my_status_exports = {};
+__export(my_status_exports, {
+  definition: () => definition5,
+  execute: () => execute5,
+  run: () => run5,
+  terminal: () => terminal5
+});
+init_github();
+import ora5 from "ora";
+var definition5 = {
+  type: "function",
+  function: {
+    name: "my_status",
+    description: "Show all tasks currently assigned to the authenticated GitHub user. Equivalent to /status.",
+    parameters: { type: "object", properties: {}, required: [] }
+  }
+};
+async function run5(config) {
+  const spinner = ora5("Fetching your tasks\u2026").start();
+  try {
+    const me = await getAuthenticatedUser(config);
+    const tasks = await listMyTasks(config, me);
+    spinner.stop();
+    if (tasks.length === 0) return `No tasks assigned to @${me}.`;
+    const lines = tasks.map((t) => `  #${t.number}  [${getStatus(t)}]  ${t.title}`);
+    return `Tasks assigned to @${me}:
+${lines.join("\n")}`;
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
+  }
+}
+var execute5 = (_input, config) => run5(config);
+var terminal5 = true;
+
+// src/tools/review/index.ts
+var review_exports = {};
+__export(review_exports, {
+  definition: () => definition6,
+  execute: () => execute6,
+  run: () => run6,
+  terminal: () => terminal6
+});
+init_github();
+import ora6 from "ora";
+var definition6 = {
+  type: "function",
+  function: {
+    name: "review",
+    description: "List tasks waiting for your review (submitted by others, created by you). Equivalent to /review.",
+    parameters: { type: "object", properties: {}, required: [] }
+  }
+};
+async function run6(config) {
+  const spinner = ora6("Loading tasks for review\u2026").start();
+  try {
+    const me = await getAuthenticatedUser(config);
+    const tasks = await listTasksForReview(config, me);
+    spinner.stop();
+    if (tasks.length === 0) return `No tasks pending review for @${me}.`;
+    const lines = tasks.map((t) => `  #${t.number}  [in-review]  @${t.assignee ?? "\u2014"}  ${t.title}`);
+    return `Tasks pending review (created by @${me}):
+${lines.join("\n")}`;
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
+  }
+}
+var execute6 = (_input, config) => run6(config);
+var terminal6 = true;
+
+// src/tools/refresh/index.ts
+var refresh_exports = {};
+__export(refresh_exports, {
+  definition: () => definition7,
+  execute: () => execute7,
+  run: () => run7,
+  terminal: () => terminal7
+});
+var definition7 = {
+  type: "function",
+  function: {
+    name: "refresh",
+    description: "Reload and display the full task list. Equivalent to /refresh.",
+    parameters: { type: "object", properties: {}, required: [] }
+  }
+};
+async function run7(config) {
+  const tasks = await printTaskList(config);
+  if (tasks.length === 0) return "No tasks found.";
+  const lines = tasks.map((t) => {
+    const status = getStatus(t);
+    const assignee = t.assignee ? `@${t.assignee}` : "\u2014";
+    return `#${t.number}  [${status}]  ${assignee}  ${t.title}`;
+  });
+  return `Tasks (${tasks.length}):
+${lines.join("\n")}`;
+}
+var execute7 = (_input, config) => run7(config);
+var terminal7 = true;
+
+// src/tools/open-code/index.ts
+var open_code_exports = {};
+__export(open_code_exports, {
+  definition: () => definition8,
+  execute: () => execute8,
+  run: () => run8,
+  terminal: () => terminal8
+});
+init_github();
+var definition8 = {
+  type: "function",
+  function: {
+    name: "open_code",
+    description: "Launch Claude Code for the current task branch. Equivalent to /code.",
+    parameters: { type: "object", properties: {}, required: [] }
+  }
+};
+async function run8(config) {
+  let branch;
+  try {
+    branch = await getCurrentBranch();
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+  const match = branch.match(/^task-(\d+)-/);
+  if (!match) return `Not on a task branch (current: ${branch}).`;
+  const issueNum = parseInt(match[1], 10);
+  let issue;
+  try {
+    issue = await getTask(config, issueNum);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+  await launchClaudeCode(issue, branch);
+  return "Claude Code session ended.";
+}
+var execute8 = (_input, config) => run8(config);
+var terminal8 = true;
+
+// src/tools/reject/index.ts
+var reject_exports = {};
+__export(reject_exports, {
+  definition: () => definition9,
+  execute: () => execute9,
+  run: () => run9,
+  terminal: () => terminal9
+});
+init_github();
+import chalk8 from "chalk";
+import { select as select5, input as promptInput3 } from "@inquirer/prompts";
+import ora7 from "ora";
+
+// src/tools/reject/prompts.ts
+var REJECTION_FORMAT = `
+Write the rejection comment in the same language as the conversation. Use markdown. Include:
+
+### \u274C \u6253\u56DE\u539F\u56E0 / Rejection Reason
+One paragraph: what was reviewed and what the main problem is.
+
+### \u{1F527} \u9700\u8981\u4FEE\u6539\u7684\u5185\u5BB9 / Required Changes
+Numbered, specific, actionable items. Reference file names and function names.
+
+### \u2705 \u672A\u901A\u8FC7\u7684\u9A8C\u6536\u6807\u51C6 / Failed Acceptance Criteria
+Re-list each criterion that was NOT met, prefixed with \u274C.
+
+### \u{1F4CB} \u4E0B\u4E00\u6B65 / Next Steps
+Clear instruction on what to fix and how to re-submit (via /submit).
+`.trim();
+
+// src/tools/reject/comment-generator.ts
+async function generateRejectionComment(config, issueNumber, userFeedback) {
+  return runSubAgentLoop(
+    config,
+    "You are a senior engineer writing a structured code review rejection comment. Use get_task to read the acceptance criteria, get_diff or read_file to inspect the implementation, and get_comments to see prior discussion. Then write the rejection comment.\n\n" + REJECTION_FORMAT,
+    `Write a rejection comment for issue #${issueNumber}.
+Reviewer feedback: ${userFeedback}`,
+    ["get_task", "get_comments", "get_diff", "read_file"]
+  );
+}
+
+// src/tools/reject/index.ts
+var definition9 = {
+  type: "function",
+  function: {
+    name: "reject",
+    description: "Reject an in-review task: collects reviewer feedback, generates a structured rejection comment, shows a preview for confirmation, then posts the comment and marks the issue as changes-needed.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "GitHub issue number to reject." },
+        feedback: { type: "string", description: "Description of what is wrong with the submission." }
+      },
+      required: ["issue_number", "feedback"]
+    }
+  }
+};
+async function run9(config, opts) {
+  const { issue_number: issueNumber } = opts;
+  let feedback;
+  try {
+    feedback = await promptInput3({
+      message: `What's wrong with #${issueNumber}? (brief description for the reviewer agent)`
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (!feedback.trim()) return "Cancelled.";
+  const divider = chalk8.dim("\u2500".repeat(70));
+  for (; ; ) {
+    const spinner = ora7("Generating rejection comment\u2026").start();
+    let comment;
+    try {
+      comment = await generateRejectionComment(config, issueNumber, feedback);
+      spinner.stop();
+    } catch (err) {
+      spinner.stop();
+      return `Error generating comment: ${err.message}`;
+    }
+    console.log("\n" + divider);
+    console.log(chalk8.bold(`  Rejection preview \u2014 issue #${issueNumber}`));
+    console.log(divider);
+    console.log(renderMarkdown(comment));
+    console.log(divider + "\n");
+    let decision;
+    try {
+      decision = await select5({
+        message: `Post rejection and mark #${issueNumber} as changes-needed?`,
+        choices: [
+          { name: "Post & Reject", value: "yes" },
+          { name: "Revise \u2014 describe what to change", value: "revise" },
+          { name: "Cancel", value: "cancel" }
+        ]
+      });
+    } catch {
+      return "Cancelled.";
+    }
+    if (decision === "cancel") return "User cancelled rejection.";
+    if (decision === "revise") {
+      try {
+        feedback = await promptInput3({ message: "What should be changed?" });
+      } catch {
+        return "Cancelled.";
+      }
+      continue;
+    }
+    let spinner2 = ora7(`Posting rejection comment on #${issueNumber}\u2026`).start();
+    try {
+      await postComment(config, issueNumber, comment);
+      spinner2.stop();
+    } catch (err) {
+      spinner2.stop();
+      return `Error posting comment: ${err.message}`;
+    }
+    spinner2 = ora7(`Marking #${issueNumber} as changes-needed\u2026`).start();
+    try {
+      await rejectTask(config, issueNumber);
+      spinner2.stop();
+    } catch (err) {
+      spinner2.stop();
+      return `Comment posted but failed to update label: ${err.message}`;
+    }
+    return `Task #${issueNumber} rejected. Label changed to changes-needed.`;
+  }
+}
+async function execute9(input, config) {
+  const issueNumber = input["issue_number"];
+  const feedback = input["feedback"];
+  let comment;
+  try {
+    comment = await generateRejectionComment(config, issueNumber, feedback);
+  } catch (err) {
+    return `Error generating comment: ${err.message}`;
+  }
+  try {
+    await postComment(config, issueNumber, comment);
+  } catch (err) {
+    return `Error posting comment: ${err.message}`;
+  }
+  try {
+    await rejectTask(config, issueNumber);
+  } catch (err) {
+    return `Comment posted but failed to update label: ${err.message}`;
+  }
+  return `Task #${issueNumber} rejected.
+
+Comment posted:
+${comment}`;
+}
+var terminal9 = true;
+
+// src/tools/accept/index.ts
+var accept_exports = {};
+__export(accept_exports, {
+  definition: () => definition10,
+  execute: () => execute10,
+  run: () => run10,
+  terminal: () => terminal10
+});
+init_github();
+import chalk9 from "chalk";
+import { select as select6 } from "@inquirer/prompts";
+import ora8 from "ora";
+var definition10 = {
+  type: "function",
+  function: {
+    name: "accept",
+    description: "Accept an in-review task: merges the PR into the configured base branch and closes the issue.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "GitHub issue number to accept" }
+      },
+      required: ["issue_number"]
+    }
+  }
+};
+async function run10(config, opts) {
+  let issueNumber = opts?.issue_number;
+  if (!issueNumber) {
+    const spinner2 = ora8("Loading tasks for review\u2026").start();
+    let tasks;
+    let me;
+    try {
+      me = await getAuthenticatedUser(config);
+      tasks = await listTasksForReview(config, me);
+      spinner2.stop();
+    } catch (err) {
+      spinner2.stop();
+      return `Error: ${err.message}`;
+    }
+    if (tasks.length === 0) return "No tasks pending review.";
+    try {
+      issueNumber = await select6({
+        message: "Which task to accept?",
+        choices: tasks.map((t) => ({
+          name: `#${t.number}  @${t.assignee ?? "\u2014"}  ${t.title}`,
+          value: t.number
+        }))
+      });
+    } catch {
+      return "Cancelled.";
+    }
+  }
+  const baseBranch = config.github.baseBranch ?? "main";
+  let confirmed;
+  try {
+    confirmed = await select6({
+      message: `Merge PR for #${issueNumber} into ${chalk9.cyan(baseBranch)} and close issue?`,
+      choices: [
+        { name: "Yes, accept", value: true },
+        { name: "Cancel", value: false }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (!confirmed) return "Cancelled.";
+  const spinner = ora8(`Merging PR for #${issueNumber}\u2026`).start();
+  try {
+    const result = await acceptTask(config, issueNumber);
+    spinner.succeed(`PR #${result.prNumber} merged into ${baseBranch}`);
+    return `Task #${issueNumber} accepted.
+PR #${result.prNumber} merged \u2192 ${baseBranch}
+Issue closed.`;
+  } catch (err) {
+    spinner.fail("Failed");
+    return `Error: ${err.message}`;
+  }
+}
+async function execute10(input, config) {
+  const issueNumber = input["issue_number"];
+  const spinner = ora8(`Merging PR for #${issueNumber}\u2026`).start();
+  try {
+    const result = await acceptTask(config, issueNumber);
+    spinner.stop();
+    const baseBranch = config.github.baseBranch ?? "main";
+    return `Task #${issueNumber} accepted.
+PR #${result.prNumber} merged \u2192 ${baseBranch}
+Issue closed.`;
+  } catch (err) {
+    spinner.stop();
+    return `Error: ${err.message}`;
+  }
+}
+var terminal10 = true;
+
+// src/tools/get-task/index.ts
+var get_task_exports = {};
+__export(get_task_exports, {
+  definition: () => definition11,
+  execute: () => execute11
+});
+init_github();
+var definition11 = {
+  type: "function",
+  function: {
+    name: "get_task",
+    description: "Get full details of a specific GitHub issue: title, body, status, assignee.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "GitHub issue number" }
+      },
+      required: ["issue_number"]
+    }
+  }
+};
+async function execute11(input, config) {
+  const issue = await getTask(config, input["issue_number"]);
+  const status = issue.labels.find((l) => l.startsWith("techunter:"))?.replace("techunter:", "") ?? "unknown";
+  const assignee = issue.assignee ? `@${issue.assignee}` : "\u2014";
+  const lines = [
+    `#${issue.number}  [${status}]  ${assignee}`,
+    `Title: ${issue.title}`,
+    `URL: ${issue.htmlUrl}`
+  ];
+  if (issue.body) lines.push(`
+${issue.body}`);
+  return lines.join("\n");
+}
+
+// src/tools/get-comments/index.ts
+var get_comments_exports = {};
+__export(get_comments_exports, {
+  definition: () => definition12,
+  execute: () => execute12
+});
+init_github();
+import ora9 from "ora";
+var definition12 = {
+  type: "function",
+  function: {
+    name: "get_comments",
+    description: "Get the latest comments on a GitHub issue. Useful for reading rejection feedback.",
+    parameters: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "GitHub issue number" },
+        limit: { type: "number", description: "Max number of latest comments to return (default 5)" }
+      },
+      required: ["issue_number"]
+    }
+  }
+};
+async function execute12(input, config) {
+  const issueNumber = input["issue_number"];
+  const limit = input["limit"] ?? 5;
+  const spinner = ora9(`Loading comments for #${issueNumber}...`).start();
+  try {
+    const comments = await listComments(config, issueNumber, limit);
+    spinner.stop();
+    if (comments.length === 0) return `No comments on issue #${issueNumber}.`;
+    const lines = comments.map((c) => `--- @${c.author} (${c.createdAt.slice(0, 10)}) ---
+${c.body}`);
+    return `Latest ${comments.length} comment(s) on #${issueNumber}:
+
+${lines.join("\n\n")}`;
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+// src/tools/get-diff/index.ts
+var get_diff_exports = {};
+__export(get_diff_exports, {
+  definition: () => definition13,
+  execute: () => execute13
+});
+import ora10 from "ora";
+var definition13 = {
+  type: "function",
+  function: {
+    name: "get_diff",
+    description: "Get the current git diff: changed files, diff vs HEAD, and any unpushed commits.",
+    parameters: { type: "object", properties: {}, required: [] }
+  }
+};
+async function execute13(_input, _config) {
+  const spinner = ora10("Reading git diff...").start();
+  try {
+    const diff = await getDiff(_config.github.baseBranch);
+    spinner.stop();
+    return diff;
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+// src/tools/run-command/index.ts
+var run_command_exports = {};
+__export(run_command_exports, {
+  definition: () => definition14,
+  execute: () => execute14
+});
+import { exec } from "child_process";
+import { promisify } from "util";
+import ora11 from "ora";
+var execAsync = promisify(exec);
+var definition14 = {
+  type: "function",
+  function: {
+    name: "run_command",
+    description: "Run a shell command in the project root directory. Use for building, testing, linting, or git status checks. stdout and stderr are both returned. Commands time out after 60 seconds.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to run" }
+      },
+      required: ["command"]
+    }
+  }
+};
+async function execute14(input, _config) {
+  const command = input["command"];
+  const cwd = process.cwd();
+  const spinner = ora11(`$ ${command}`).start();
+  try {
+    const { stdout, stderr } = await execAsync(command, { cwd, timeout: 6e4, maxBuffer: 1024 * 1024 });
+    spinner.stop();
+    const out = [stdout, stderr].filter(Boolean).join("\n").trim();
+    const result = out.length > 5e3 ? out.slice(0, 5e3) + "\n... (truncated)" : out;
+    return result || "(no output)";
+  } catch (err) {
+    spinner.stop();
+    const e = err;
+    const out = [e.stdout, e.stderr].filter(Boolean).join("\n").trim();
+    return `Exit ${e.code ?? 1}:
+${out || e.message}`;
+  }
+}
+
+// src/tools/scan-project/index.ts
+var scan_project_exports = {};
+__export(scan_project_exports, {
+  definition: () => definition15,
+  execute: () => execute15
+});
+import ora12 from "ora";
+
+// src/lib/project.ts
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import path2 from "path";
+import { globby } from "globby";
+import ignore from "ignore";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".ico",
+  ".webp",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".rar",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".db",
+  ".sqlite",
+  ".lock"
+]);
+var ALWAYS_READ = [
+  "README.md",
+  "README.txt",
+  "README",
+  "package.json",
+  "pyproject.toml",
+  "go.mod",
+  "Cargo.toml",
+  "tsconfig.json",
+  "vite.config.ts",
+  "vite.config.js",
+  "webpack.config.js",
+  "rollup.config.js",
+  ".env.example",
+  "docker-compose.yml",
+  "Dockerfile"
+];
+var MAX_TOTAL_BYTES = 8e4;
+var MAX_FILE_BYTES = 15e3;
+async function buildIgnoreFilter(cwd) {
+  const ig = ignore();
+  const gitignorePath = path2.join(cwd, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = await readFile2(gitignorePath, "utf-8");
+    ig.add(content);
+  }
+  ig.add(["node_modules", "dist", ".git", ".next", "__pycache__", "*.pyc", "build", "coverage"]);
+  return ig;
+}
+async function safeReadFile(filePath, maxBytes = MAX_FILE_BYTES) {
+  try {
+    const content = await readFile2(filePath, "utf-8");
+    if (content.length > maxBytes) {
+      return content.slice(0, maxBytes) + `
+... (truncated at ${maxBytes} chars)`;
+    }
+    return content;
+  } catch {
+    return null;
+  }
+}
+function isBinaryFile(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+function buildFileTree(files) {
+  const tree = {};
+  for (const file of files) {
+    const dir = path2.dirname(file);
+    if (!tree[dir]) tree[dir] = [];
+    tree[dir].push(path2.basename(file));
+  }
+  const lines = [];
+  const rootFiles = tree["."] ?? [];
+  for (const f of rootFiles) lines.push(f);
+  const dirs = Object.keys(tree).filter((d) => d !== ".").sort();
+  for (const dir of dirs) {
+    lines.push(`${dir}/`);
+    for (const f of tree[dir]) {
+      lines.push(`  ${f}`);
+    }
+  }
+  return lines.join("\n");
+}
+function scoreRelevance(filePath, keywords) {
+  const lower = filePath.toLowerCase();
+  let score = 0;
+  for (const kw of keywords) {
+    if (lower.includes(kw)) score += 1;
+  }
+  return score;
+}
+async function buildProjectContext(cwd, issueTitle, issueBody) {
+  const ig = await buildIgnoreFilter(cwd);
+  const allFiles = await globby("**/*", {
+    cwd,
+    gitignore: false,
+    // We handle ignore ourselves
+    dot: false,
+    onlyFiles: true
+  });
+  const filtered = allFiles.filter((f) => !ig.ignores(f) && !isBinaryFile(f));
+  const fileTree = buildFileTree(filtered);
+  const issueText = `${issueTitle} ${issueBody}`.toLowerCase();
+  const keywords = issueText.replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 3);
+  const keyFiles = {};
+  let totalBytes = 0;
+  for (const always of ALWAYS_READ) {
+    if (totalBytes >= MAX_TOTAL_BYTES) break;
+    const fullPath = path2.join(cwd, always);
+    if (!existsSync(fullPath)) continue;
+    const content = await safeReadFile(fullPath);
+    if (content !== null) {
+      keyFiles[always] = content;
+      totalBytes += content.length;
+    }
+  }
+  const scored = filtered.filter((f) => !ALWAYS_READ.includes(f) && !ALWAYS_READ.includes(path2.basename(f))).map((f) => ({ file: f, score: scoreRelevance(f, keywords) })).filter((x) => x.score > 0).sort((a, b) => b.score - a.score).slice(0, 10);
+  for (const { file } of scored) {
+    if (totalBytes >= MAX_TOTAL_BYTES) break;
+    const fullPath = path2.join(cwd, file);
+    const content = await safeReadFile(fullPath);
+    if (content !== null) {
+      keyFiles[file] = content;
+      totalBytes += content.length;
+    }
+  }
+  return { fileTree, keyFiles };
+}
+
+// src/tools/scan-project/index.ts
+var definition15 = {
+  type: "function",
+  function: {
+    name: "scan_project",
+    description: "Scan the current project directory: returns the file tree and contents of the most relevant files. Call this when creating a new task to understand the codebase before writing the task body and guide.",
+    parameters: {
+      type: "object",
+      properties: {
+        focus: {
+          type: "string",
+          description: "Keywords describing the task. Used to prioritise which files to read."
+        }
+      },
+      required: []
+    }
+  }
+};
+async function execute15(input, _config) {
+  const focus = input["focus"] ?? "";
+  const spinner = ora12("Scanning project...").start();
+  try {
+    const cwd = process.cwd();
+    const context = await buildProjectContext(cwd, focus, "");
+    spinner.stop();
+    const fileCount = context.fileTree.split("\n").filter(Boolean).length;
+    const readCount = Object.keys(context.keyFiles).length;
+    const totalBytes = Object.values(context.keyFiles).reduce((s, c) => s + c.length, 0);
+    const summary = `Scanned ${fileCount} files \xB7 ${readCount} read \xB7 ${(totalBytes / 1024).toFixed(1)} KB`;
+    const parts = [summary, `## File tree
+\`\`\`
+${context.fileTree}
+\`\`\``];
+    for (const [filePath, content] of Object.entries(context.keyFiles)) {
+      parts.push(`## ${filePath}
+\`\`\`
+${content}
+\`\`\``);
+    }
+    return parts.join("\n\n");
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+}
+
+// src/tools/read-file/index.ts
+var read_file_exports = {};
+__export(read_file_exports, {
+  definition: () => definition16,
+  execute: () => execute16
+});
+import { readFile as readFile3 } from "fs/promises";
+import path3 from "path";
+var definition16 = {
+  type: "function",
+  function: {
+    name: "read_file",
+    description: "Read the full contents of a specific file in the project.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path relative to the project root" }
+      },
+      required: ["path"]
+    }
+  }
+};
+async function execute16(input, _config) {
+  const filePath = input["path"];
+  try {
+    const fullPath = path3.join(process.cwd(), filePath);
+    const content = await readFile3(fullPath, "utf-8");
+    return content.length > 15e3 ? content.slice(0, 15e3) + "\n\n... (truncated)" : content;
+  } catch (err) {
+    return `Error reading file: ${err.message}`;
+  }
+}
+
+// src/tools/ask-user/index.ts
+var ask_user_exports = {};
+__export(ask_user_exports, {
+  definition: () => definition17,
+  execute: () => execute17
+});
+import chalk10 from "chalk";
+import { select as select7, input as promptInput4 } from "@inquirer/prompts";
+var definition17 = {
+  type: "function",
+  function: {
+    name: "ask_user",
+    description: "Ask the user to clarify something ambiguous \u2014 scope, expected behaviour, edge cases, or business decisions. Do NOT ask about technical implementation choices. Use at most 3 times per task.",
+    parameters: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "The question to ask the user" },
+        options: {
+          type: "array",
+          items: { type: "string" },
+          description: "2\u20134 concrete answer choices"
+        }
+      },
+      required: ["question", "options"]
+    }
+  }
+};
+async function execute17(input, _config) {
+  const question = input["question"];
+  const options = input["options"];
+  const OTHER = "__other__";
+  console.log("");
+  console.log(chalk10.dim("  \u250C\u2500 Agent question " + "\u2500".repeat(51)));
+  console.log(chalk10.dim("  \u2502"));
+  for (const line of question.split("\n")) {
+    console.log(chalk10.dim("  \u2502 ") + line);
+  }
+  console.log(chalk10.dim("  \u2514" + "\u2500".repeat(67)));
+  let answer;
+  try {
+    const chosen = await select7({
+      message: " ",
+      choices: [
+        ...options.map((o) => ({ name: o, value: o })),
+        { name: chalk10.dim("Other (describe below)"), value: OTHER }
+      ]
+    });
+    answer = chosen === OTHER ? await promptInput4({ message: "Your answer:" }) : chosen;
+  } catch {
+    answer = "User skipped this question \u2014 use your best judgement.";
+  }
+  console.log("");
+  return answer;
+}
+
+// src/tools/registry.ts
+var toolModules = [
+  // Command tools
+  pick_exports,
+  new_task_exports,
+  close_exports,
+  submit_exports,
+  my_status_exports,
+  review_exports,
+  refresh_exports,
+  open_code_exports,
+  reject_exports,
+  accept_exports,
+  // Low-level tools
+  get_task_exports,
+  get_comments_exports,
+  get_diff_exports,
+  run_command_exports,
+  scan_project_exports,
+  read_file_exports,
+  ask_user_exports
+];
+
+// src/lib/config.ts
+import Conf from "conf";
+import { z } from "zod";
+var configSchema = z.object({
+  aiApiKey: z.string().min(1),
+  aiBaseUrl: z.string().optional(),
+  aiModel: z.string().optional(),
+  githubToken: z.string().min(1),
+  githubClientId: z.string().optional(),
+  github: z.object({
+    owner: z.string().min(1),
+    repo: z.string().min(1),
+    baseBranch: z.string().optional()
+  })
+});
+var store = new Conf({
+  projectName: "techunter",
+  defaults: {}
+});
+function getConfig() {
+  const raw = store.store;
+  const result = configSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error("Configuration is missing or invalid.");
+  }
+  return result.data;
+}
+
+// src/mcp.ts
+var tools = toolModules.filter((m) => m.definition.function.name !== "ask_user");
+var server = new Server(
+  { name: "techunter", version: "0.1.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: tools.map((m) => ({
+    name: m.definition.function.name,
+    description: m.definition.function.description,
+    inputSchema: m.definition.function.parameters
+  }))
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const mod = tools.find((m) => m.definition.function.name === request.params.name);
+  if (!mod) {
+    return { content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }], isError: true };
+  }
+  try {
+    const config = getConfig();
+    const result = await mod.execute(request.params.arguments ?? {}, config);
+    return { content: [{ type: "text", text: result }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+  }
+});
+var transport = new StdioServerTransport();
+await server.connect(transport);