techunter 0.1.0

package/dist/index.js

@@ -0,0 +1,2865 @@
+#!/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/index.ts
+import chalk14 from "chalk";
+import readline from "readline";
+import { createRequire } from "module";
+
+// src/commands/init.ts
+import { input, password, select } from "@inquirer/prompts";
+import chalk2 from "chalk";
+import ora from "ora";
+import open from "open";
+import { createOAuthDeviceAuth } from "@octokit/auth-oauth-device";
+
+// 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;
+}
+function setConfig(partial) {
+  const current = store.store;
+  if (partial.github) {
+    current["github"] = {
+      ...current["github"] ?? {},
+      ...partial.github
+    };
+  }
+  if (partial.aiApiKey !== void 0) {
+    current["aiApiKey"] = partial.aiApiKey;
+  }
+  if (partial.aiBaseUrl !== void 0) {
+    current["aiBaseUrl"] = partial.aiBaseUrl;
+  }
+  if (partial.aiModel !== void 0) {
+    current["aiModel"] = partial.aiModel;
+  }
+  if (partial.githubToken !== void 0) {
+    current["githubToken"] = partial.githubToken;
+  }
+  if (partial.githubClientId !== void 0) {
+    current["githubClientId"] = partial.githubClientId;
+  }
+  store.store = current;
+}
+function getConfigPath() {
+  return store.path;
+}
+
+// src/commands/init.ts
+init_github();
+
+// 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"]);
+}
+async function getRemoteUrl() {
+  try {
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    return origin?.refs?.fetch ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseOwnerRepo(remoteUrl) {
+  const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/([^.]+?)(?:\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1], repo: sshMatch[2] };
+  }
+  const httpsMatch = remoteUrl.match(/https?:\/\/github\.com\/([^/]+)\/([^.]+?)(?:\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1], repo: httpsMatch[2] };
+  }
+  return null;
+}
+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/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/commands/init.ts
+async function getGitHubTokenViaPAT() {
+  console.log(chalk2.dim("\n  Create a token at: https://github.com/settings/tokens/new"));
+  console.log(chalk2.dim("  Required scopes: repo, read:user\n"));
+  const token = await password({
+    message: "GitHub Personal Access Token:",
+    mask: "*"
+  });
+  return { token: token.trim() };
+}
+var OAUTH_CLIENT_ID = "Ov23liW4zJ4r2RdZOsCJ";
+async function getGitHubTokenViaDeviceFlow() {
+  let verificationUri = "";
+  let userCode = "";
+  const auth = createOAuthDeviceAuth({
+    clientType: "oauth-app",
+    clientId: OAUTH_CLIENT_ID,
+    scopes: ["repo"],
+    onVerification(verification) {
+      verificationUri = verification.verification_uri;
+      userCode = verification.user_code;
+      console.log("");
+      console.log(chalk2.bold("  1. Open this URL in your browser:"));
+      console.log("     " + chalk2.cyan(verificationUri));
+      console.log("");
+      console.log(chalk2.bold("  2. Enter this code:"));
+      console.log("     " + chalk2.yellow.bold(userCode));
+      console.log("");
+      open(verificationUri).catch(() => {
+      });
+    }
+  });
+  const spinner = ora("Waiting for authorization in browser...").start();
+  let token;
+  try {
+    const result = await auth({ type: "oauth" });
+    token = result.token;
+    spinner.succeed("Authorized!");
+  } catch (err) {
+    spinner.fail("Authorization failed");
+    throw err;
+  }
+  return { token, clientId: OAUTH_CLIENT_ID };
+}
+async function initCommand() {
+  console.log(chalk2.bold.cyan("\nTechunter \u2014 Initial Setup\n"));
+  let detectedOwner = "";
+  let detectedRepo = "";
+  const remoteUrl = await getRemoteUrl();
+  if (remoteUrl) {
+    const parsed = parseOwnerRepo(remoteUrl);
+    if (parsed) {
+      detectedOwner = parsed.owner;
+      detectedRepo = parsed.repo;
+      console.log(chalk2.dim(`Detected GitHub repo: ${detectedOwner}/${detectedRepo}
+`));
+    }
+  }
+  const authMethod = await select({
+    message: "How would you like to authenticate with GitHub?",
+    choices: [
+      {
+        name: "Browser login (OAuth) \u2014 open a URL and click Authorize",
+        value: "device"
+      },
+      {
+        name: "Personal Access Token (PAT) \u2014 paste a token from github.com/settings/tokens",
+        value: "pat"
+      }
+    ]
+  });
+  let githubToken;
+  let githubClientId;
+  if (authMethod === "device") {
+    const result = await getGitHubTokenViaDeviceFlow();
+    githubToken = result.token;
+    githubClientId = result.clientId;
+  } else {
+    const result = await getGitHubTokenViaPAT();
+    githubToken = result.token;
+  }
+  const providerChoice = await select({
+    message: "AI provider:",
+    choices: [
+      { name: `OpenRouter (recommended)  ${chalk2.dim(`${DEFAULT_BASE_URL}  \xB7  ${DEFAULT_MODEL}`)}`, value: "openrouter" },
+      { name: "Custom (specify base URL and model)", value: "custom" }
+    ]
+  });
+  let aiBaseUrl;
+  let aiModel;
+  if (providerChoice === "custom") {
+    aiBaseUrl = (await input({ message: "API base URL:", default: DEFAULT_BASE_URL })).trim();
+    aiModel = (await input({ message: "Model name:", default: DEFAULT_MODEL })).trim();
+  }
+  const apiKeyHint = providerChoice === "openrouter" ? chalk2.dim("  Get a key at: https://openrouter.ai/settings/keys\n") : chalk2.dim("  API key for your provider\n");
+  console.log(apiKeyHint);
+  const aiApiKey = await password({
+    message: "API Key:",
+    mask: "*"
+  });
+  let owner = detectedOwner;
+  let repo = detectedRepo;
+  if (!owner || !repo) {
+    owner = await input({
+      message: "GitHub repo owner (user or org):",
+      required: true
+    });
+    repo = await input({
+      message: "GitHub repo name:",
+      required: true
+    });
+  }
+  const detectedDefault = "main";
+  const baseBranch = await input({
+    message: "Main branch to merge PRs into:",
+    default: detectedDefault
+  });
+  const config = {
+    githubToken,
+    githubClientId,
+    aiApiKey: aiApiKey.trim(),
+    ...aiBaseUrl ? { aiBaseUrl } : {},
+    ...aiModel ? { aiModel } : {},
+    github: {
+      owner: owner.trim(),
+      repo: repo.trim(),
+      baseBranch: baseBranch.trim() || detectedDefault
+    }
+  };
+  setConfig(config);
+  const spinner = ora("Setting up GitHub labels...").start();
+  try {
+    await ensureLabels(config);
+    spinner.succeed("GitHub labels created");
+  } catch (err) {
+    spinner.fail("Failed to create labels (check token permissions)");
+    console.error(chalk2.red(String(err)));
+  }
+  console.log(chalk2.green("\nSetup complete!"));
+  console.log(chalk2.dim(`Config saved to: ${getConfigPath()}
+`));
+}
+
+// src/commands/config.ts
+import { input as input2, password as password2, select as select2 } from "@inquirer/prompts";
+import chalk3 from "chalk";
+async function configCommand() {
+  let config;
+  try {
+    config = getConfig();
+  } catch {
+    console.error(chalk3.red("No config found. Run `tch init` first."));
+    process.exit(1);
+  }
+  console.log(chalk3.bold.cyan("\nTechunter \u2014 Settings\n"));
+  console.log(chalk3.dim(`Config file: ${getConfigPath()}
+`));
+  const currentBaseUrl = config.aiBaseUrl ?? DEFAULT_BASE_URL;
+  const currentModel = config.aiModel ?? DEFAULT_MODEL;
+  const field = await select2({
+    message: "Which setting to change?",
+    choices: [
+      { name: `Base branch          ${chalk3.dim(config.github.baseBranch ?? "(not set, uses repo default)")}`, value: "baseBranch" },
+      { name: `GitHub repo          ${chalk3.dim(`${config.github.owner}/${config.github.repo}`)}`, value: "repo" },
+      { name: `AI base URL          ${chalk3.dim(currentBaseUrl)}`, value: "aiBaseUrl" },
+      { name: `AI model             ${chalk3.dim(currentModel)}`, value: "aiModel" },
+      { name: `AI API Key           ${chalk3.dim("(hidden)")}`, value: "aiApiKey" },
+      { name: `GitHub Token         ${chalk3.dim("(hidden)")}`, value: "githubToken" },
+      { name: "Cancel", value: "cancel" }
+    ]
+  });
+  if (field === "cancel") return;
+  if (field === "baseBranch") {
+    const val = await input2({
+      message: "Main branch to merge PRs into:",
+      default: config.github.baseBranch ?? "main"
+    });
+    setConfig({ github: { ...config.github, baseBranch: val.trim() || "main" } });
+    console.log(chalk3.green(`
+Base branch set to: ${val.trim() || "main"}
+`));
+  } else if (field === "repo") {
+    const owner = await input2({ message: "GitHub repo owner:", default: config.github.owner });
+    const repo = await input2({ message: "GitHub repo name:", default: config.github.repo });
+    setConfig({ github: { ...config.github, owner: owner.trim(), repo: repo.trim() } });
+    console.log(chalk3.green(`
+Repo set to: ${owner.trim()}/${repo.trim()}
+`));
+  } else if (field === "aiBaseUrl") {
+    const val = await input2({ message: "AI base URL:", default: currentBaseUrl });
+    if (val.trim()) {
+      setConfig({ aiBaseUrl: val.trim() });
+      console.log(chalk3.green(`
+AI base URL set to: ${val.trim()}
+`));
+    }
+  } else if (field === "aiModel") {
+    const val = await input2({ message: "AI model name:", default: currentModel });
+    if (val.trim()) {
+      setConfig({ aiModel: val.trim() });
+      console.log(chalk3.green(`
+AI model set to: ${val.trim()}
+`));
+    }
+  } else if (field === "aiApiKey") {
+    const val = await password2({ message: "New AI API Key:", mask: "*" });
+    if (val.trim()) {
+      setConfig({ aiApiKey: val.trim() });
+      console.log(chalk3.green("\nAI API Key updated.\n"));
+    }
+  } else if (field === "githubToken") {
+    const val = await password2({ message: "New GitHub Token:", mask: "*" });
+    if (val.trim()) {
+      setConfig({ githubToken: val.trim() });
+      console.log(chalk3.green("\nGitHub Token updated.\n"));
+    }
+  }
+}
+
+// src/index.ts
+init_github();
+
+// src/lib/agent.ts
+import ora14 from "ora";
+import chalk13 from "chalk";
+
+// src/tools/pick/index.ts
+var pick_exports = {};
+__export(pick_exports, {
+  definition: () => definition3,
+  execute: () => execute3,
+  run: () => run3,
+  terminal: () => terminal3
+});
+init_github();
+import chalk8 from "chalk";
+import ora4 from "ora";
+import { select as select5 } from "@inquirer/prompts";
+
+// 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 chalk4 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 chalk4.green(padded);
+    case "claimed":
+      return chalk4.yellow(padded);
+    case "in-review":
+      return chalk4.blue(padded);
+    case "changes-needed":
+      return chalk4.red(padded);
+    default:
+      return padded;
+  }
+}
+function printTaskDetail(issue) {
+  const divider = chalk4.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  console.log(
+    chalk4.bold(` #${issue.number}`) + "  " + colorStatus(getStatus(issue)) + "  " + chalk4.dim(issue.assignee ? `@${issue.assignee}` : "\u2014")
+  );
+  console.log(chalk4.bold("\n " + issue.title));
+  if (issue.body) {
+    console.log("");
+    console.log(renderMarkdown(issue.body));
+  }
+  console.log("\n " + chalk4.dim(issue.htmlUrl));
+  console.log(divider + "\n");
+}
+async function printTaskList(config) {
+  try {
+    const tasks = await listTasks(config);
+    const divider = chalk4.dim("\u2500".repeat(70));
+    console.log("");
+    console.log(chalk4.dim(" " + "#".padEnd(5) + "Status".padEnd(14) + "Assignee".padEnd(16) + "Title"));
+    console.log(divider);
+    if (tasks.length === 0) {
+      console.log(chalk4.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(chalk4.yellow(`(Could not load tasks: ${err.message})`));
+    return [];
+  }
+}
+async function printMyTasks(config) {
+  try {
+    const me = await getAuthenticatedUser(config);
+    const tasks = await listMyTasks(config, me);
+    if (tasks.length === 0) return;
+    const divider = chalk4.dim("\u2500".repeat(70));
+    console.log("");
+    console.log(chalk4.dim(" " + "#".padEnd(5) + "Status".padEnd(14) + `My Tasks  @${me}`));
+    console.log(divider);
+    for (const t of tasks) {
+      const num = `#${t.number}`.padEnd(5);
+      const status = colorStatus(getStatus(t));
+      const title = t.title.length > 46 ? t.title.slice(0, 43) + "..." : t.title;
+      console.log(` ${num}${status}${title}`);
+    }
+    console.log(divider);
+    const rejectedTasks = tasks.filter((t) => t.labels.includes(LABEL_CHANGES_NEEDED2));
+    if (rejectedTasks.length > 0) {
+      let currentBranch = "";
+      try {
+        currentBranch = await getCurrentBranch();
+      } catch {
+      }
+      console.log("");
+      for (const t of rejectedTasks) {
+        const expectedBranch = makeBranchName(t.number, t.title);
+        const onCorrectBranch = currentBranch === expectedBranch;
+        console.log(
+          chalk4.red.bold("  \u26A0 Changes requested") + chalk4.red(` on #${t.number} "${t.title}"`)
+        );
+        if (!onCorrectBranch) {
+          console.log(
+            chalk4.dim("    Switch branch: ") + chalk4.cyan(`git checkout ${expectedBranch}`)
+          );
+        }
+      }
+      console.log("");
+    }
+  } catch {
+  }
+}
+
+// src/lib/launch.ts
+import { spawn } from "child_process";
+import chalk5 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(chalk5.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(
+        chalk5.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 chalk7 from "chalk";
+import ora2 from "ora";
+import { select as select3, input as promptInput } from "@inquirer/prompts";
+
+// src/lib/agent-ui.ts
+import chalk6 from "chalk";
+function formatInput(input3) {
+  return Object.entries(input3).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, input3) {
+  const params = formatInput(input3);
+  console.log(`  ${chalk6.cyan("\u2192")} ${chalk6.bold(name)}${params ? "  " + chalk6.dim(params) : ""}`);
+}
+function printToolResult(result) {
+  const ok = !result.startsWith("Error:");
+  const icon = ok ? chalk6.green("\u2713") : chalk6.red("\u2717");
+  console.log(`  ${icon} ${chalk6.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 input3;
+        try {
+          input3 = JSON.parse(tc.function.arguments);
+        } catch {
+          input3 = {};
+        }
+        printToolCall(tc.function.name, input3);
+        const mod = selected.find((m) => m.definition.function.name === tc.function.name);
+        const result = mod ? await mod.execute(input3, 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 = ora2("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 = ora2("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 = chalk7.dim("\u2500".repeat(70));
+  console.log("\n" + divider);
+  console.log(chalk7.bold(`  Review \u2014 task #${issueNumber} "${issue.title}"`));
+  console.log(divider);
+  console.log(renderMarkdown(review));
+  console.log(divider + "\n");
+  let shouldProceed;
+  try {
+    shouldProceed = await select3({
+      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 = ora2("Committing and pushing\u2026").start();
+  try {
+    await stageAllAndCommit(commitMessage.trim());
+    spinner.stop();
+  } catch (err) {
+    spinner.stop();
+    return `Commit failed: ${err.message}`;
+  }
+  spinner = ora2("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 = ora2("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(input3, 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 = input3["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 select4 } from "@inquirer/prompts";
+import ora3 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 select4({
+        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 select4({
+      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 = ora3(`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(input3, config) {
+  const issueNumber = input3["issue_number"];
+  const spinner = ora3(`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 select5({
+        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 = chalk8.dim("\u2500".repeat(70));
+        console.log(
+          chalk8.red.bold("  Latest rejection feedback") + chalk8.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 select5({ 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 = ora4(`Claiming #${issue.number}\u2026`).start();
+      await claimTask(config, issue.number, me);
+      spinner.stop();
+      const branch = makeBranchName(issue.number, me);
+      spinner = ora4(`Creating branch ${branch}\u2026`).start();
+      try {
+        await createAndSwitchBranch(branch);
+        spinner.stop();
+      } catch {
+        spinner.warn(`Could not create branch ${branch}`);
+      }
+      spinner = ora4("Pushing branch\u2026").start();
+      try {
+        await pushBranch(branch);
+        spinner.stop();
+      } catch {
+        spinner.warn("Could not push branch");
+      }
+      console.log(chalk8.green(`
+  Claimed! Branch: ${branch}
+`));
+      let openClaude;
+      try {
+        openClaude = await select5({
+          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(input3, config) {
+  const issueNumber = input3["issue_number"];
+  const action = input3["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 select6, 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 ora5 from "ora";
+import chalk9 from "chalk";
+import open2 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 = ora5("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 = chalk9.dim("\u2500".repeat(70));
+  for (; ; ) {
+    console.log("\n" + divider);
+    console.log(chalk9.bold("  Generated guide preview"));
+    console.log(divider);
+    console.log(renderMarkdown(guide));
+    console.log(divider + "\n");
+    let action;
+    try {
+      action = await select6({
+        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(chalk9.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 = ora5("Revising guide\u2026").start();
+    try {
+      guide = await generateGuide(config, title, { feedback, previousGuide: guide });
+      reviseSpinner.stop();
+    } catch (err) {
+      reviseSpinner.stop();
+      console.log(chalk9.yellow(`  Revision error: ${err.message}`));
+    }
+  }
+  const createSpinner = ora5(`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(chalk9.green(`
+  Created #${issueNumber} "${issueTitle}"
+  ${chalk9.dim(htmlUrl)}
+`));
+  try {
+    const openBrowser = await select6({
+      message: "Open issue in browser?",
+      choices: [
+        { name: "Yes", value: true },
+        { name: "No", value: false }
+      ]
+    });
+    if (openBrowser) await open2(htmlUrl);
+  } catch {
+  }
+  return `Created #${issueNumber} "${issueTitle}" \u2014 ${htmlUrl}`;
+}
+async function execute4(input3, config) {
+  const title = input3["title"].trim();
+  const feedback = input3["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 ora6 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 = ora6("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 ora7 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 = ora7("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 chalk10 from "chalk";
+import { select as select7, input as promptInput3 } from "@inquirer/prompts";
+import ora8 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 = chalk10.dim("\u2500".repeat(70));
+  for (; ; ) {
+    const spinner = ora8("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(chalk10.bold(`  Rejection preview \u2014 issue #${issueNumber}`));
+    console.log(divider);
+    console.log(renderMarkdown(comment));
+    console.log(divider + "\n");
+    let decision;
+    try {
+      decision = await select7({
+        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 = ora8(`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 = ora8(`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(input3, config) {
+  const issueNumber = input3["issue_number"];
+  const feedback = input3["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 chalk11 from "chalk";
+import { select as select8 } from "@inquirer/prompts";
+import ora9 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 = ora9("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 select8({
+        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 select8({
+      message: `Merge PR for #${issueNumber} into ${chalk11.cyan(baseBranch)} and close issue?`,
+      choices: [
+        { name: "Yes, accept", value: true },
+        { name: "Cancel", value: false }
+      ]
+    });
+  } catch {
+    return "Cancelled.";
+  }
+  if (!confirmed) return "Cancelled.";
+  const spinner = ora9(`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(input3, config) {
+  const issueNumber = input3["issue_number"];
+  const spinner = ora9(`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(input3, config) {
+  const issue = await getTask(config, input3["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 ora10 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(input3, config) {
+  const issueNumber = input3["issue_number"];
+  const limit = input3["limit"] ?? 5;
+  const spinner = ora10(`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 ora11 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 = ora11("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 ora12 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(input3, _config) {
+  const command = input3["command"];
+  const cwd = process.cwd();
+  const spinner = ora12(`$ ${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 ora13 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(input3, _config) {
+  const focus = input3["focus"] ?? "";
+  const spinner = ora13("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(input3, _config) {
+  const filePath = input3["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 chalk12 from "chalk";
+import { select as select9, 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(input3, _config) {
+  const question = input3["question"];
+  const options = input3["options"];
+  const OTHER = "__other__";
+  console.log("");
+  console.log(chalk12.dim("  \u250C\u2500 Agent question " + "\u2500".repeat(51)));
+  console.log(chalk12.dim("  \u2502"));
+  for (const line of question.split("\n")) {
+    console.log(chalk12.dim("  \u2502 ") + line);
+  }
+  console.log(chalk12.dim("  \u2514" + "\u2500".repeat(67)));
+  let answer;
+  try {
+    const chosen = await select9({
+      message: " ",
+      choices: [
+        ...options.map((o) => ({ name: o, value: o })),
+        { name: chalk12.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/agent.ts
+var tools = toolModules.map((m) => m.definition);
+async function executeTool(name, input3, config) {
+  const mod = toolModules.find((m) => m.definition.function.name === name);
+  if (!mod) return `Unknown tool: ${name}`;
+  try {
+    return await mod.execute(input3, config);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+async function runAgentLoop(config, messages) {
+  const client = createClient(config);
+  const { owner, repo } = config.github;
+  const systemMessage = {
+    role: "system",
+    content: [
+      "You are Techunter, an AI assistant managing GitHub tasks for a development team.",
+      `Repository: ${owner}/${repo}`,
+      "Respond in the same language the user writes in (Chinese or English).",
+      "For conversational replies be concise. For task guides be thorough and detailed.",
+      "Always use tools when the user requests an action.",
+      "",
+      "## Tool philosophy",
+      "Command tools (pick, new_task, close, submit, my_status, review, refresh, open_code) run",
+      "hardcoded interactive flows \u2014 always use these for user-facing actions.",
+      "Low-level tools are for reasoning: run_command, scan_project, read_file, ask_user,",
+      "get_task, get_comments, get_diff.",
+      "",
+      "## Creating a task",
+      "If the task description is vague, call ask_user to clarify (max 3 times).",
+      "Then call new_task with the title \u2014 the tool scans the project and generates the guide automatically.",
+      "",
+      "## Claiming a task",
+      "Call pick with the issue_number \u2014 the tool handles everything.",
+      "Do NOT scan or generate anything for claiming.",
+      "",
+      "## Rejecting a task",
+      "Call reject with the issue_number \u2014 the tool collects feedback and generates the comment.",
+      "",
+      "## Submitting changes",
+      "When the user asks to submit, deliver, push, or finish their work:",
+      "Call submit directly \u2014 it handles AI review, confirmation, commit, and PR creation.",
+      "",
+      "## Reviewing submitted tasks",
+      "When the user asks to review tasks or check what needs approval:",
+      "1. Call review to list tasks pending your approval.",
+      "2. Call get_task to read full details of the task to review.",
+      "3. Call get_comments to read the implementation guide and any discussion.",
+      "4. To approve: call close with the issue_number.",
+      "5. To reject: write a structured rejection comment and call reject."
+    ].join("\n")
+  };
+  const MAX_ITERATIONS = 30;
+  let iterations = 0;
+  for (; ; ) {
+    if (++iterations > MAX_ITERATIONS) {
+      throw new Error(`Agent exceeded ${MAX_ITERATIONS} iterations without finishing.`);
+    }
+    const isWindows = process.platform === "win32";
+    const spinner = isWindows ? null : ora14({ text: chalk13.dim("Thinking\u2026"), color: "cyan" }).start();
+    if (isWindows) process.stdout.write(chalk13.dim("  Thinking\u2026"));
+    let response;
+    try {
+      response = await client.chat.completions.create({
+        model: getModel(config),
+        tools,
+        messages: [systemMessage, ...messages]
+      });
+    } catch (err) {
+      if (spinner) spinner.stop();
+      else process.stdout.write("\r" + " ".repeat(14) + "\r");
+      throw err;
+    }
+    if (spinner) spinner.stop();
+    else process.stdout.write("\r" + " ".repeat(14) + "\r");
+    const choice = response.choices[0];
+    const assistantMessage = {
+      role: "assistant",
+      content: choice.message.content ?? null,
+      ...choice.message.tool_calls ? { tool_calls: choice.message.tool_calls } : {}
+    };
+    messages.push(assistantMessage);
+    if (choice.finish_reason === "stop") {
+      return choice.message.content ?? "";
+    }
+    if (choice.finish_reason === "tool_calls") {
+      const toolCalls = choice.message.tool_calls ?? [];
+      for (const tc of toolCalls) {
+        let parsed;
+        try {
+          parsed = JSON.parse(tc.function.arguments);
+        } catch {
+          parsed = {};
+        }
+        printToolCall(tc.function.name, parsed);
+      }
+      const results = await Promise.all(
+        toolCalls.map((tc) => {
+          let parsed;
+          try {
+            parsed = JSON.parse(tc.function.arguments);
+          } catch {
+            parsed = {};
+          }
+          return executeTool(tc.function.name, parsed, config);
+        })
+      );
+      let terminal11 = false;
+      for (let i = 0; i < toolCalls.length; i++) {
+        printToolResult(results[i]);
+        messages.push({
+          role: "tool",
+          tool_call_id: toolCalls[i].id,
+          content: results[i]
+        });
+        if (toolModules.find((m) => m.definition.function.name === toolCalls[i].function.name)?.terminal) {
+          terminal11 = true;
+        }
+      }
+      if (terminal11) return results[results.length - 1];
+    } else {
+      return choice.message.content ?? "";
+    }
+  }
+}
+
+// src/index.ts
+var _require = createRequire(import.meta.url);
+var { version } = _require("../package.json");
+var SLASH_NAMES = [
+  "/help",
+  "/h",
+  "/refresh",
+  "/r",
+  "/pick",
+  "/p",
+  "/new",
+  "/n",
+  "/submit",
+  "/s",
+  "/close",
+  "/d",
+  "/review",
+  "/rv",
+  "/accept",
+  "/ac",
+  "/status",
+  "/me",
+  "/code",
+  "/c",
+  "/config",
+  "/cfg"
+];
+function completer(line) {
+  if (line.startsWith("/")) {
+    const hits = SLASH_NAMES.filter((c) => c.startsWith(line));
+    return [hits.length ? hits : SLASH_NAMES, line];
+  }
+  return [[], line];
+}
+var _rl = null;
+function promptUser() {
+  return new Promise((resolve) => {
+    _rl.question(chalk14.cyan("You") + chalk14.dim(" \u203A "), resolve);
+  });
+}
+var COMMANDS = [
+  { cmd: "/help", alias: "/h", desc: "Show available commands" },
+  { cmd: "/refresh", alias: "/r", desc: "Reload the task list" },
+  { cmd: "/pick", alias: "/p", desc: "Browse tasks and view details" },
+  { cmd: "/new", alias: "/n", desc: "Create a new task interactively" },
+  { cmd: "/close", alias: "/d", desc: "Close (delete) a task" },
+  { cmd: "/submit", alias: "/s", desc: "Commit, create PR, and mark in-review" },
+  { cmd: "/review", alias: "/rv", desc: "List tasks waiting for your approval" },
+  { cmd: "/accept", alias: "/ac", desc: "Accept a reviewed task: merge PR and close issue" },
+  { cmd: "/config", alias: "/cfg", desc: "Change settings (branch, repo, API keys)" },
+  { cmd: "/status", alias: "/me", desc: "Show tasks assigned to you" },
+  { cmd: "/code", alias: "/c", desc: "Open Claude Code for the current task branch" }
+];
+function cmdHelp() {
+  console.log("");
+  console.log(chalk14.bold("  Commands"));
+  console.log(chalk14.dim("  \u2500".repeat(35)));
+  for (const { cmd, alias, desc } of COMMANDS) {
+    const left = (cmd + (alias ? `  ${chalk14.dim(alias)}` : "")).padEnd(22);
+    console.log(`  ${chalk14.cyan(cmd)}${alias ? "  " + chalk14.dim(alias) : ""}`.padEnd(30) + chalk14.dim(desc));
+  }
+  console.log(chalk14.dim("\n  Anything else is sent to the AI agent.\n"));
+}
+function printBanner(config) {
+  const { owner, repo } = config.github;
+  const g = chalk14.cyan;
+  const b = chalk14.bold.white;
+  const p = chalk14.yellow.bold;
+  console.log("");
+  console.log("    " + g("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  console.log(p("\u25C6") + b("\u2550\u2550\u2550") + g("\u256C") + b("   TECHUNTER   ") + g("\u256C") + b("\u2550\u2550\u2550\u25B6"));
+  console.log("    " + g("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  console.log("");
+  console.log(
+    "    " + chalk14.bold("Techunter") + chalk14.dim(` v${version}`) + chalk14.dim("  \xB7  ") + chalk14.cyan("GLM-5") + chalk14.dim(" \xB7 zai-org") + chalk14.dim("  \xB7  ") + chalk14.dim(`${owner}/${repo}`)
+  );
+  console.log("");
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === "config") {
+    try {
+      await configCommand();
+    } catch (err) {
+      console.error(chalk14.red(`
+Error: ${err.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  let config;
+  try {
+    config = getConfig();
+  } catch {
+    try {
+      await initCommand();
+      config = getConfig();
+    } catch (err) {
+      console.error(chalk14.red(`
+Setup failed: ${err.message}`));
+      process.exit(1);
+      return;
+    }
+  }
+  const remoteUrl = await getRemoteUrl();
+  if (remoteUrl) {
+    const detected = parseOwnerRepo(remoteUrl);
+    if (detected) {
+      const isNewRepo = detected.owner !== config.github.owner || detected.repo !== config.github.repo;
+      config = { ...config, github: { ...config.github, owner: detected.owner, repo: detected.repo, baseBranch: void 0 } };
+      if (isNewRepo) {
+        console.log(chalk14.dim(`  Repo: ${detected.owner}/${detected.repo}`));
+        ensureLabels(config).catch(() => {
+        });
+      }
+    }
+  } else if (!config.github.owner) {
+    console.error(chalk14.red("\nNo git remote found and no repo configured. Run tch init."));
+    process.exit(1);
+  }
+  printBanner(config);
+  console.log(chalk14.dim("  Type /help for commands, or describe what you want.\n"));
+  await printTaskList(config);
+  await printMyTasks(config);
+  _rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    completer,
+    terminal: true
+  });
+  _rl.on("close", () => {
+    console.log(chalk14.gray("\nGoodbye!"));
+    process.exit(0);
+  });
+  _rl.on("SIGINT", () => {
+    console.log(chalk14.gray("\nGoodbye!"));
+    process.exit(0);
+  });
+  const messages = [];
+  for (; ; ) {
+    const userInput = (await promptUser()).trim();
+    _rl.pause();
+    if (!userInput) continue;
+    const cmd = userInput.split(/\s+/)[0].toLowerCase();
+    if (cmd.startsWith("/")) {
+      switch (cmd) {
+        case "/help":
+        case "/h":
+          cmdHelp();
+          break;
+        case "/refresh":
+        case "/r":
+          await run7(config);
+          break;
+        case "/pick":
+        case "/p": {
+          const arg = userInput.slice(cmd.length).trim().replace(/^#/, "");
+          const preselected = arg ? parseInt(arg, 10) : void 0;
+          const result = await run3(config, Number.isNaN(preselected) ? void 0 : preselected);
+          if (result && result !== "Cancelled.") {
+            console.log(chalk14.green(`
+  ${result}
+`));
+          }
+          await printTaskList(config);
+          break;
+        }
+        case "/new":
+        case "/n": {
+          const result = await run4(config);
+          console.log(chalk14.green(`
+  ${result}
+`));
+          await printTaskList(config);
+          break;
+        }
+        case "/submit":
+        case "/s": {
+          const result = await run(config);
+          console.log("\n" + renderMarkdown(result));
+          await printTaskList(config);
+          break;
+        }
+        case "/close":
+        case "/d": {
+          const result = await run2(config);
+          console.log(chalk14.green(`
+  ${result}
+`));
+          await printTaskList(config);
+          break;
+        }
+        case "/review":
+        case "/rv": {
+          const result = await run6(config);
+          console.log("\n" + renderMarkdown(result));
+          break;
+        }
+        case "/status":
+        case "/me": {
+          const result = await run5(config);
+          console.log("\n" + renderMarkdown(result));
+          break;
+        }
+        case "/accept":
+        case "/ac": {
+          const arg = userInput.slice(cmd.length).trim().replace(/^#/, "");
+          const preselected = arg ? parseInt(arg, 10) : void 0;
+          const result = await run10(config, Number.isNaN(preselected) ? void 0 : { issue_number: preselected });
+          console.log(chalk14.green(`
+  ${result}
+`));
+          await printTaskList(config);
+          break;
+        }
+        case "/config":
+        case "/cfg":
+          await configCommand();
+          break;
+        case "/code":
+        case "/c":
+          await run8(config);
+          break;
+        default:
+          console.log(chalk14.yellow(`  Unknown command: ${cmd}  (try /help)`));
+      }
+      continue;
+    }
+    const prevLength = messages.length;
+    messages.push({ role: "user", content: userInput });
+    try {
+      const response = await runAgentLoop(config, messages);
+      console.log("\n" + chalk14.green("Techunter:") + "\n" + renderMarkdown(response));
+    } catch (err) {
+      messages.splice(prevLength);
+      console.error(chalk14.red(`
+Error: ${err.message}
+`));
+    }
+    await printTaskList(config);
+  }
+}
+main().catch((err) => {
+  console.error(chalk14.red(`Fatal: ${err.message}`));
+  process.exit(1);
+});