@rotorsoft/gent 1.0.0

package/dist/index.js

@@ -0,0 +1,1184 @@
+#!/usr/bin/env node
+import {
+  addIssueComment,
+  assignIssue,
+  buildIssueLabels,
+  checkClaudeCli,
+  checkGhAuth,
+  checkGitRepo,
+  colors,
+  configExists,
+  createIssue,
+  createPullRequest,
+  extractPriorityFromLabels,
+  extractTypeFromLabels,
+  generateDefaultConfig,
+  getConfigPath,
+  getCurrentUser,
+  getIssue,
+  getPrForBranch,
+  getWorkflowLabels,
+  isValidIssueNumber,
+  listIssues,
+  loadAgentInstructions,
+  loadConfig,
+  logger,
+  sanitizeSlug,
+  setupLabelsCommand,
+  sortByPriority,
+  updateIssueLabels,
+  withSpinner
+} from "./chunk-NRTQPDZB.js";
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import inquirer from "inquirer";
+
+// src/lib/progress.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+function getProgressPath(config, cwd = process.cwd()) {
+  return join(cwd, config.progress.file);
+}
+function progressExists(config, cwd = process.cwd()) {
+  return existsSync(getProgressPath(config, cwd));
+}
+function readProgress(config, cwd = process.cwd()) {
+  const path = getProgressPath(config, cwd);
+  if (!existsSync(path)) {
+    return "";
+  }
+  return readFileSync(path, "utf-8");
+}
+function initializeProgress(config, cwd = process.cwd()) {
+  const path = getProgressPath(config, cwd);
+  if (existsSync(path)) {
+    return;
+  }
+  const initialContent = `# Progress Log
+
+This file tracks AI-assisted development progress.
+Each entry documents: date, feature, decisions, files changed, tests, and concerns.
+
+---
+`;
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path, initialContent, "utf-8");
+}
+
+// src/commands/init.ts
+var DEFAULT_AGENT_MD = `# AI Agent Instructions
+
+This file contains instructions for Claude when working on this repository.
+
+## Project Overview
+
+[Describe your project, its purpose, and key technologies used]
+
+## Code Patterns
+
+### Architecture
+[Document your architecture - e.g., MVC, Clean Architecture, etc.]
+
+### Naming Conventions
+[Document naming conventions for files, functions, variables, etc.]
+
+### Component Structure
+[If applicable, describe component/module structure]
+
+## Testing Requirements
+
+### Unit Tests
+- All new functions should have corresponding unit tests
+- Use [your testing framework] for unit tests
+- Aim for [X]% coverage on new code
+
+### Integration Tests
+[Document when and how to write integration tests]
+
+## Commit Conventions
+
+Follow conventional commits format:
+- \`feat:\` New feature
+- \`fix:\` Bug fix
+- \`refactor:\` Code improvement without behavior change
+- \`test:\` Testing additions
+- \`chore:\` Maintenance/dependencies
+- \`docs:\` Documentation
+
+All AI commits should include:
+\`\`\`
+Co-Authored-By: Claude <noreply@anthropic.com>
+\`\`\`
+
+## Important Files
+
+[List key files the AI should understand before making changes]
+
+- \`src/index.ts\` - Main entry point
+- \`src/config/\` - Configuration files
+- [Add more key files]
+
+## Constraints
+
+- [List any constraints or limitations]
+- [E.g., "Do not modify files in /vendor"]
+- [E.g., "Always use async/await over callbacks"]
+`;
+async function initCommand(options) {
+  logger.bold("Initializing gent workflow...");
+  logger.newline();
+  const isGitRepo = await checkGitRepo();
+  if (!isGitRepo) {
+    logger.error("Not a git repository. Please run 'git init' first.");
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  if (configExists(cwd) && !options.force) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "gent is already initialized. Overwrite existing config?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      logger.info("Initialization cancelled.");
+      return;
+    }
+  }
+  const configPath = getConfigPath(cwd);
+  writeFileSync2(configPath, generateDefaultConfig(), "utf-8");
+  logger.success(`Created ${colors.file(".gent.yml")}`);
+  const agentPath = join2(cwd, "AGENT.md");
+  if (!existsSync2(agentPath) || options.force) {
+    writeFileSync2(agentPath, DEFAULT_AGENT_MD, "utf-8");
+    logger.success(`Created ${colors.file("AGENT.md")}`);
+  } else {
+    logger.info(`${colors.file("AGENT.md")} already exists, skipping`);
+  }
+  const config = loadConfig(cwd);
+  initializeProgress(config, cwd);
+  logger.success(`Created ${colors.file(config.progress.file)}`);
+  logger.newline();
+  logger.box("Setup Complete", `Next steps:
+1. Edit ${colors.file("AGENT.md")} with your project-specific instructions
+2. Edit ${colors.file(".gent.yml")} to customize settings
+3. Run ${colors.command("gent setup-labels")} to create GitHub labels
+4. Run ${colors.command("gent create <description>")} to create your first ticket`);
+  const { setupLabels } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "setupLabels",
+      message: "Would you like to setup GitHub labels now?",
+      default: true
+    }
+  ]);
+  if (setupLabels) {
+    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-2YOKZ2AK.js");
+    await setupLabelsCommand2();
+  }
+}
+
+// src/lib/claude.ts
+import { spawn } from "child_process";
+import { execa } from "execa";
+async function invokeClaude(options) {
+  const args = ["--print"];
+  if (options.permissionMode) {
+    args.push("--permission-mode", options.permissionMode);
+  }
+  args.push(options.prompt);
+  if (options.printOutput) {
+    const subprocess = execa("claude", args, {
+      stdio: "inherit"
+    });
+    await subprocess;
+    return "";
+  } else if (options.streamOutput) {
+    return new Promise((resolve, reject) => {
+      const child = spawn("claude", args, {
+        stdio: ["inherit", "pipe", "pipe"]
+      });
+      let output = "";
+      child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        output += text;
+        process.stdout.write(text);
+      });
+      child.stderr.on("data", (chunk) => {
+        process.stderr.write(chunk);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(output);
+        } else {
+          reject(new Error(`Claude exited with code ${code}`));
+        }
+      });
+      child.on("error", reject);
+    });
+  } else {
+    const { stdout } = await execa("claude", args);
+    return stdout;
+  }
+}
+async function invokeClaudeInteractive(prompt, config) {
+  const args = ["--permission-mode", config.claude.permission_mode, prompt];
+  return execa("claude", args, {
+    stdio: "inherit"
+  });
+}
+function buildTicketPrompt(description, agentInstructions) {
+  const basePrompt = `You are creating a GitHub issue for a software project following an AI-assisted development workflow.
+
+User Request: ${description}
+
+${agentInstructions ? `Project-Specific Instructions:
+${agentInstructions}
+
+` : ""}
+
+Create a detailed GitHub issue following this exact template:
+
+## Description
+[Clear user-facing description of what needs to be done]
+
+## Technical Context
+**Type:** feature | fix | refactor | chore | docs | test
+**Category:** ui | api | database | workers | shared | testing | infra
+**Priority:** critical | high | medium | low
+**Risk:** low | medium | high
+
+### Architecture Notes
+- [Relevant patterns to follow]
+- [Related systems affected]
+- [Constraints or invariants]
+
+## Implementation Steps
+- [ ] Step 1: Specific technical task
+- [ ] Step 2: Specific technical task
+- [ ] Step 3: Specific technical task
+
+## Testing Requirements
+- **Unit tests:** [What to test]
+- **Integration tests:** [What to test if applicable]
+- **Manual verification:** [What to check]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+---
+IMPORTANT: After the issue content, on a new line, output ONLY the following metadata in this exact format:
+META:type=<type>,priority=<priority>,risk=<risk>,area=<area>
+
+Example: META:type=feature,priority=high,risk=low,area=ui`;
+  return basePrompt;
+}
+function buildImplementationPrompt(issue, agentInstructions, progressContent, config) {
+  return `GitHub Issue #${issue.number}: ${issue.title}
+
+${issue.body}
+
+${agentInstructions ? `## Project-Specific Instructions
+${agentInstructions}
+
+` : ""}
+${progressContent ? `## Previous Progress
+${progressContent}
+
+` : ""}
+
+## Your Task
+
+1. **Implement the feature/fix** following patterns from the project's AGENT.md or codebase conventions
+2. **Add unit tests** for any new functionality
+3. **Run validation** before committing:
+${config.validation.map((cmd) => `   - ${cmd}`).join("\n")}
+4. **Make an atomic commit** with a clear message following conventional commits format:
+   - Use format: <type>: <description>
+   - Include "Completed GitHub issue #${issue.number}" in body
+   - End with: Co-Authored-By: Claude <noreply@anthropic.com>
+5. **Do NOT push** - the user will review and push manually
+
+Focus on clean, minimal implementation. Don't over-engineer.`;
+}
+function buildPrPrompt(issue, commits, diffSummary) {
+  return `Generate a pull request description for the following changes.
+
+${issue ? `## Related Issue
+#${issue.number}: ${issue.title}
+
+${issue.body}
+
+` : ""}
+
+## Commits
+${commits.map((c) => `- ${c}`).join("\n")}
+
+## Changed Files
+${diffSummary}
+
+Generate a PR description in this format:
+
+## Summary
+- [1-3 bullet points summarizing the changes]
+
+## Test Plan
+- [ ] [Testing steps]
+
+${issue ? `Closes #${issue.number}` : ""}
+
+Only output the PR description, nothing else.`;
+}
+function parseTicketMeta(output) {
+  const metaMatch = output.match(
+    /META:type=(\w+),priority=(\w+),risk=(\w+),area=(\w+)/
+  );
+  if (!metaMatch) {
+    return null;
+  }
+  return {
+    type: metaMatch[1],
+    priority: metaMatch[2],
+    risk: metaMatch[3],
+    area: metaMatch[4]
+  };
+}
+function extractIssueBody(output) {
+  return output.replace(/\n?META:type=\w+,priority=\w+,risk=\w+,area=\w+\s*$/, "").trim();
+}
+
+// src/commands/create.ts
+async function createCommand(description) {
+  logger.bold("Creating AI-enhanced ticket...");
+  logger.newline();
+  const [ghAuth, claudeOk] = await Promise.all([checkGhAuth(), checkClaudeCli()]);
+  if (!ghAuth) {
+    logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
+    process.exit(1);
+  }
+  if (!claudeOk) {
+    logger.error("Claude CLI not found. Please install claude CLI first.");
+    process.exit(1);
+  }
+  const agentInstructions = loadAgentInstructions();
+  const prompt = buildTicketPrompt(description, agentInstructions);
+  let claudeOutput;
+  try {
+    logger.info("Generating ticket with Claude...");
+    logger.newline();
+    claudeOutput = await invokeClaude({ prompt, streamOutput: true });
+    logger.newline();
+  } catch (error) {
+    logger.error(`Claude invocation failed: ${error}`);
+    return;
+  }
+  const meta = parseTicketMeta(claudeOutput);
+  if (!meta) {
+    logger.warning("Could not parse metadata from Claude output. Using defaults.");
+  }
+  const finalMeta = meta || {
+    type: "feature",
+    priority: "medium",
+    risk: "low",
+    area: "shared"
+  };
+  const issueBody = extractIssueBody(claudeOutput);
+  const title = description.length > 60 ? description.slice(0, 57) + "..." : description;
+  const labels = buildIssueLabels(finalMeta);
+  let issueNumber;
+  try {
+    issueNumber = await withSpinner("Creating GitHub issue...", async () => {
+      return createIssue({
+        title,
+        body: issueBody,
+        labels
+      });
+    });
+  } catch (error) {
+    logger.error(`Failed to create issue: ${error}`);
+    return;
+  }
+  logger.newline();
+  logger.success(`Created issue ${colors.issue(`#${issueNumber}`)}`);
+  logger.newline();
+  logger.box("Issue Created", `Issue: ${colors.issue(`#${issueNumber}`)}
+Type: ${colors.label(`type:${finalMeta.type}`)}
+Priority: ${colors.label(`priority:${finalMeta.priority}`)}
+Risk: ${colors.label(`risk:${finalMeta.risk}`)}
+Area: ${colors.label(`area:${finalMeta.area}`)}
+
+Next steps:
+1. Review the issue on GitHub
+2. Run ${colors.command(`gent run ${issueNumber}`)} to implement`);
+}
+
+// src/commands/list.ts
+import chalk from "chalk";
+async function listCommand(options) {
+  const isAuthed = await checkGhAuth();
+  if (!isAuthed) {
+    logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const workflowLabels = getWorkflowLabels(config);
+  const labels = [];
+  if (options.label) {
+    labels.push(options.label);
+  }
+  if (options.status && options.status !== "all") {
+    switch (options.status) {
+      case "ready":
+        labels.push(workflowLabels.ready);
+        break;
+      case "in-progress":
+        labels.push(workflowLabels.inProgress);
+        break;
+      case "completed":
+        labels.push(workflowLabels.completed);
+        break;
+      case "blocked":
+        labels.push(workflowLabels.blocked);
+        break;
+    }
+  } else if (!options.status) {
+    labels.push(workflowLabels.ready);
+  }
+  let issues;
+  try {
+    issues = await listIssues({
+      labels: labels.length > 0 ? labels : void 0,
+      state: "open",
+      limit: options.limit || 20
+    });
+  } catch (error) {
+    logger.error(`Failed to fetch issues: ${error}`);
+    return;
+  }
+  if (issues.length === 0) {
+    logger.info("No issues found matching the criteria.");
+    return;
+  }
+  sortByPriority(issues);
+  logger.bold(`Found ${issues.length} issue(s):`);
+  logger.newline();
+  for (const issue of issues) {
+    const type = extractTypeFromLabels(issue.labels);
+    const priority = extractPriorityFromLabels(issue.labels);
+    const status = getIssueStatus(issue.labels, workflowLabels);
+    const priorityColor = getPriorityColor(priority);
+    const statusColor = getStatusColor(status);
+    console.log(
+      `  ${colors.issue(`#${issue.number.toString().padStart(4)}`)} ${priorityColor(`[${priority}]`.padEnd(10))} ${statusColor(`[${status}]`.padEnd(14))} ${colors.label(`[${type}]`.padEnd(10))} ` + issue.title.slice(0, 50) + (issue.title.length > 50 ? "..." : "")
+    );
+  }
+  logger.newline();
+  logger.dim(`Run ${colors.command("gent run <issue-number>")} to implement an issue`);
+  logger.dim(`Run ${colors.command("gent run --auto")} to auto-select highest priority`);
+}
+function getIssueStatus(labels, workflowLabels) {
+  if (labels.includes(workflowLabels.ready)) return "ready";
+  if (labels.includes(workflowLabels.inProgress)) return "in-progress";
+  if (labels.includes(workflowLabels.completed)) return "completed";
+  if (labels.includes(workflowLabels.blocked)) return "blocked";
+  return "unknown";
+}
+function getPriorityColor(priority) {
+  switch (priority) {
+    case "critical":
+      return chalk.red;
+    case "high":
+      return chalk.yellow;
+    case "medium":
+      return chalk.blue;
+    case "low":
+      return chalk.green;
+    default:
+      return chalk.gray;
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "ready":
+      return chalk.green;
+    case "in-progress":
+      return chalk.yellow;
+    case "completed":
+      return chalk.blue;
+    case "blocked":
+      return chalk.red;
+    default:
+      return chalk.gray;
+  }
+}
+
+// src/commands/run.ts
+import inquirer2 from "inquirer";
+
+// src/lib/git.ts
+import { execa as execa2 } from "execa";
+async function getCurrentBranch() {
+  const { stdout } = await execa2("git", ["branch", "--show-current"]);
+  return stdout.trim();
+}
+async function isOnMainBranch() {
+  const branch = await getCurrentBranch();
+  return branch === "main" || branch === "master";
+}
+async function getDefaultBranch() {
+  try {
+    const { stdout } = await execa2("git", [
+      "symbolic-ref",
+      "refs/remotes/origin/HEAD"
+    ]);
+    return stdout.trim().replace("refs/remotes/origin/", "");
+  } catch {
+    try {
+      await execa2("git", ["rev-parse", "--verify", "main"]);
+      return "main";
+    } catch {
+      return "master";
+    }
+  }
+}
+async function branchExists(name) {
+  try {
+    await execa2("git", ["rev-parse", "--verify", name]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function createBranch(name, from) {
+  if (from) {
+    await execa2("git", ["checkout", "-b", name, from]);
+  } else {
+    await execa2("git", ["checkout", "-b", name]);
+  }
+}
+async function checkoutBranch(name) {
+  await execa2("git", ["checkout", name]);
+}
+async function hasUncommittedChanges() {
+  const { stdout } = await execa2("git", ["status", "--porcelain"]);
+  return stdout.trim().length > 0;
+}
+async function getUnpushedCommits() {
+  try {
+    const { stdout } = await execa2("git", [
+      "log",
+      "@{u}..HEAD",
+      "--oneline"
+    ]);
+    return stdout.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+async function pushBranch(branch) {
+  const branchName = branch || await getCurrentBranch();
+  await execa2("git", ["push", "-u", "origin", branchName]);
+}
+async function getAuthorInitials() {
+  try {
+    const { stdout } = await execa2("git", ["config", "user.initials"]);
+    if (stdout.trim()) {
+      return stdout.trim();
+    }
+  } catch {
+  }
+  try {
+    const { stdout } = await execa2("git", ["config", "user.name"]);
+    const name = stdout.trim();
+    if (name) {
+      const parts = name.split(/\s+/);
+      return parts.map((p) => p[0]?.toLowerCase() || "").join("");
+    }
+  } catch {
+  }
+  return "dev";
+}
+async function getCommitsSinceBase(base = "main") {
+  try {
+    const { stdout } = await execa2("git", [
+      "log",
+      `${base}..HEAD`,
+      "--pretty=format:%s"
+    ]);
+    return stdout.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function getDiffSummary(base = "main") {
+  try {
+    const { stdout } = await execa2("git", [
+      "diff",
+      `${base}...HEAD`,
+      "--stat"
+    ]);
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+
+// src/lib/branch.ts
+async function generateBranchName(config, issueNumber, issueTitle, type) {
+  const author = await resolveAuthor(config);
+  const slug = sanitizeSlug(issueTitle);
+  return config.branch.pattern.replace("{author}", author).replace("{type}", type).replace("{issue}", String(issueNumber)).replace("{slug}", slug);
+}
+async function resolveAuthor(config) {
+  switch (config.branch.author_source) {
+    case "env": {
+      const envValue = process.env[config.branch.author_env_var];
+      if (envValue) {
+        return envValue;
+      }
+      return getAuthorInitials();
+    }
+    case "git":
+    default:
+      return getAuthorInitials();
+  }
+}
+function parseBranchName(branchName) {
+  const pattern1 = /^([^/]+)\/(feature|fix|refactor|chore|docs|test)-(\d+)-(.+)$/;
+  const match1 = branchName.match(pattern1);
+  if (match1) {
+    return {
+      name: branchName,
+      author: match1[1],
+      type: match1[2],
+      issueNumber: parseInt(match1[3], 10),
+      slug: match1[4]
+    };
+  }
+  const pattern2 = /^(feature|fix|refactor|chore|docs|test)\/(\d+)-(.+)$/;
+  const match2 = branchName.match(pattern2);
+  if (match2) {
+    return {
+      name: branchName,
+      author: "",
+      type: match2[1],
+      issueNumber: parseInt(match2[2], 10),
+      slug: match2[3]
+    };
+  }
+  const pattern3 = /^(\d+)-(.+)$/;
+  const match3 = branchName.match(pattern3);
+  if (match3) {
+    return {
+      name: branchName,
+      author: "",
+      type: "feature",
+      issueNumber: parseInt(match3[1], 10),
+      slug: match3[2]
+    };
+  }
+  const issueMatch = branchName.match(/(\d+)/);
+  if (issueMatch) {
+    return {
+      name: branchName,
+      author: "",
+      type: "feature",
+      issueNumber: parseInt(issueMatch[1], 10),
+      slug: branchName
+    };
+  }
+  return null;
+}
+function extractIssueNumber(branchName) {
+  const info = parseBranchName(branchName);
+  return info?.issueNumber ?? null;
+}
+
+// src/commands/run.ts
+async function runCommand(issueNumberArg, options) {
+  logger.bold("Running AI implementation workflow...");
+  logger.newline();
+  const [ghAuth, claudeOk] = await Promise.all([checkGhAuth(), checkClaudeCli()]);
+  if (!ghAuth) {
+    logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
+    process.exit(1);
+  }
+  if (!claudeOk) {
+    logger.error("Claude CLI not found. Please install claude CLI first.");
+    process.exit(1);
+  }
+  const hasChanges = await hasUncommittedChanges();
+  if (hasChanges) {
+    logger.warning("You have uncommitted changes.");
+    const { proceed } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Continue anyway?",
+        default: false
+      }
+    ]);
+    if (!proceed) {
+      logger.info("Aborting. Please commit or stash your changes first.");
+      process.exit(0);
+    }
+  }
+  const config = loadConfig();
+  const workflowLabels = getWorkflowLabels(config);
+  let issueNumber;
+  if (options.auto) {
+    const autoIssue = await autoSelectIssue(workflowLabels.ready);
+    if (!autoIssue) {
+      logger.error("No ai-ready issues found.");
+      process.exit(1);
+    }
+    issueNumber = autoIssue.number;
+    logger.info(`Auto-selected: ${colors.issue(`#${issueNumber}`)} - ${autoIssue.title}`);
+  } else if (issueNumberArg) {
+    if (!isValidIssueNumber(issueNumberArg)) {
+      logger.error("Invalid issue number.");
+      process.exit(1);
+    }
+    issueNumber = parseInt(issueNumberArg, 10);
+  } else {
+    logger.error("Please provide an issue number or use --auto");
+    process.exit(1);
+  }
+  let issue;
+  try {
+    issue = await withSpinner("Fetching issue...", async () => {
+      return getIssue(issueNumber);
+    });
+  } catch (error) {
+    logger.error(`Failed to fetch issue #${issueNumber}: ${error}`);
+    return;
+  }
+  if (!issue.labels.includes(workflowLabels.ready)) {
+    logger.warning(`Issue #${issueNumber} does not have the '${workflowLabels.ready}' label.`);
+    const { proceed } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "proceed",
+        message: "Continue anyway?",
+        default: false
+      }
+    ]);
+    if (!proceed) {
+      return;
+    }
+  }
+  logger.newline();
+  logger.box("Issue Details", `#${issue.number}: ${issue.title}
+Labels: ${issue.labels.join(", ")}`);
+  logger.newline();
+  const type = extractTypeFromLabels(issue.labels);
+  const branchName = await generateBranchName(config, issueNumber, issue.title, type);
+  const currentBranch = await getCurrentBranch();
+  const onMain = await isOnMainBranch();
+  if (await branchExists(branchName)) {
+    logger.info(`Branch ${colors.branch(branchName)} already exists.`);
+    const { action } = await inquirer2.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "What would you like to do?",
+        choices: [
+          { name: "Continue on existing branch", value: "continue" },
+          { name: "Delete and recreate branch", value: "recreate" },
+          { name: "Cancel", value: "cancel" }
+        ]
+      }
+    ]);
+    if (action === "cancel") {
+      return;
+    } else if (action === "continue") {
+      await checkoutBranch(branchName);
+    } else {
+      await checkoutBranch(branchName);
+    }
+  } else {
+    if (!onMain) {
+      logger.warning(`Not on main branch (currently on ${colors.branch(currentBranch)}).`);
+      const { fromMain } = await inquirer2.prompt([
+        {
+          type: "confirm",
+          name: "fromMain",
+          message: "Create branch from main instead?",
+          default: true
+        }
+      ]);
+      if (fromMain) {
+        await createBranch(branchName, "main");
+      } else {
+        await createBranch(branchName);
+      }
+    } else {
+      await createBranch(branchName);
+    }
+    logger.success(`Created branch ${colors.branch(branchName)}`);
+  }
+  try {
+    await updateIssueLabels(issueNumber, {
+      add: [workflowLabels.inProgress],
+      remove: [workflowLabels.ready]
+    });
+    logger.success(`Updated issue labels: ${colors.label(workflowLabels.ready)} \u2192 ${colors.label(workflowLabels.inProgress)}`);
+  } catch (error) {
+    logger.warning(`Failed to update labels: ${error}`);
+  }
+  const agentInstructions = loadAgentInstructions();
+  const progressContent = readProgress(config);
+  const prompt = buildImplementationPrompt(issue, agentInstructions, progressContent, config);
+  logger.newline();
+  logger.info("Starting Claude implementation session...");
+  logger.dim("Claude will implement the feature and create a commit.");
+  logger.dim("Review the changes before pushing.");
+  logger.newline();
+  try {
+    await invokeClaudeInteractive(prompt, config);
+  } catch (error) {
+    logger.error(`Claude session failed: ${error}`);
+  }
+  logger.newline();
+  logger.success("Claude session completed.");
+  try {
+    await updateIssueLabels(issueNumber, {
+      add: [workflowLabels.completed],
+      remove: [workflowLabels.inProgress]
+    });
+    logger.success(`Updated labels: ${colors.label(workflowLabels.inProgress)} \u2192 ${colors.label(workflowLabels.completed)}`);
+  } catch (error) {
+    logger.warning(`Failed to update labels: ${error}`);
+  }
+  try {
+    await addIssueComment(
+      issueNumber,
+      `AI implementation completed on branch \`${branchName}\`.
+
+Please review the changes and create a PR when ready.`
+    );
+    logger.success("Posted completion comment to issue");
+  } catch (error) {
+    logger.warning(`Failed to post comment: ${error}`);
+  }
+  logger.newline();
+  logger.box("Next Steps", `1. Review changes: ${colors.command("git diff HEAD~1")}
+2. Run tests: ${colors.command("npm test")}
+3. Push branch: ${colors.command("git push -u origin " + branchName)}
+4. Create PR: ${colors.command("gent pr")}`);
+}
+async function autoSelectIssue(readyLabel) {
+  let issues = await listIssues({
+    labels: [readyLabel, "priority:critical"],
+    state: "open",
+    limit: 1
+  });
+  if (issues.length > 0) return issues[0];
+  issues = await listIssues({
+    labels: [readyLabel, "priority:high"],
+    state: "open",
+    limit: 1
+  });
+  if (issues.length > 0) return issues[0];
+  issues = await listIssues({
+    labels: [readyLabel],
+    state: "open",
+    limit: 10
+  });
+  if (issues.length === 0) return null;
+  sortByPriority(issues);
+  return issues[0];
+}
+
+// src/commands/pr.ts
+import inquirer3 from "inquirer";
+async function prCommand(options) {
+  logger.bold("Creating AI-enhanced pull request...");
+  logger.newline();
+  const [ghAuth, claudeOk] = await Promise.all([checkGhAuth(), checkClaudeCli()]);
+  if (!ghAuth) {
+    logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
+    process.exit(1);
+  }
+  if (!claudeOk) {
+    logger.error("Claude CLI not found. Please install claude CLI first.");
+    process.exit(1);
+  }
+  if (await isOnMainBranch()) {
+    logger.error("Cannot create PR from main/master branch.");
+    process.exit(1);
+  }
+  const existingPr = await getPrForBranch();
+  if (existingPr) {
+    logger.warning(`A PR already exists for this branch: ${colors.url(existingPr.url)}`);
+    return;
+  }
+  const currentBranch = await getCurrentBranch();
+  const baseBranch = await getDefaultBranch();
+  logger.info(`Branch: ${colors.branch(currentBranch)}`);
+  logger.info(`Base: ${colors.branch(baseBranch)}`);
+  const hasUnpushed = await getUnpushedCommits();
+  if (hasUnpushed) {
+    logger.warning("Branch has unpushed commits.");
+    const { push } = await inquirer3.prompt([
+      {
+        type: "confirm",
+        name: "push",
+        message: "Push to remote before creating PR?",
+        default: true
+      }
+    ]);
+    if (push) {
+      await withSpinner("Pushing branch...", async () => {
+        await pushBranch();
+      });
+      logger.success("Branch pushed");
+    }
+  }
+  const issueNumber = extractIssueNumber(currentBranch);
+  let issue = null;
+  if (issueNumber) {
+    try {
+      issue = await getIssue(issueNumber);
+      logger.info(`Linked issue: ${colors.issue(`#${issueNumber}`)} - ${issue.title}`);
+    } catch {
+      logger.warning(`Could not fetch issue #${issueNumber}`);
+    }
+  } else {
+    logger.warning("Could not extract issue number from branch name.");
+  }
+  const commits = await getCommitsSinceBase(baseBranch);
+  const diffSummary = await getDiffSummary(baseBranch);
+  if (commits.length === 0) {
+    logger.error("No commits found since base branch.");
+    return;
+  }
+  logger.info(`Commits: ${commits.length}`);
+  logger.newline();
+  const prompt = buildPrPrompt(issue, commits, diffSummary);
+  let prBody;
+  try {
+    logger.info("Generating PR description with Claude...");
+    logger.newline();
+    prBody = await invokeClaude({ prompt, streamOutput: true });
+    logger.newline();
+  } catch (error) {
+    logger.warning(`Claude invocation failed: ${error}`);
+    prBody = generateFallbackBody(issue, commits);
+  }
+  const prTitle = issue?.title || commits[0] || currentBranch;
+  let prUrl;
+  try {
+    prUrl = await withSpinner("Creating pull request...", async () => {
+      return createPullRequest({
+        title: prTitle,
+        body: prBody,
+        base: baseBranch,
+        draft: options.draft
+      });
+    });
+  } catch (error) {
+    logger.error(`Failed to create PR: ${error}`);
+    return;
+  }
+  if (issueNumber) {
+    try {
+      const user = await getCurrentUser();
+      await assignIssue(issueNumber, user);
+      logger.success(`Assigned issue #${issueNumber} to ${user}`);
+    } catch {
+    }
+  }
+  logger.newline();
+  logger.success(`Pull request created!`);
+  logger.newline();
+  logger.highlight(prUrl);
+  logger.newline();
+  if (options.draft) {
+    logger.dim("Created as draft. Mark as ready for review when done.");
+  }
+}
+function generateFallbackBody(issue, commits) {
+  let body = "## Summary\n\n";
+  if (issue) {
+    body += `Implements #${issue.number}: ${issue.title}
+
+`;
+  }
+  body += "## Changes\n\n";
+  for (const commit of commits.slice(0, 10)) {
+    body += `- ${commit}
+`;
+  }
+  body += "\n## Test Plan\n\n- [ ] Tests pass\n- [ ] Manual verification\n\n";
+  if (issue) {
+    body += `Closes #${issue.number}
+`;
+  }
+  return body;
+}
+
+// src/commands/status.ts
+async function statusCommand() {
+  logger.bold("Gent Workflow Status");
+  logger.newline();
+  const gitRepo = await checkGitRepo();
+  if (!gitRepo) {
+    logger.error("Not a git repository.");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const workflowLabels = getWorkflowLabels(config);
+  logger.bold("Configuration:");
+  if (configExists()) {
+    logger.success("  .gent.yml found");
+  } else {
+    logger.warning("  .gent.yml not found - using defaults");
+  }
+  if (progressExists(config)) {
+    const progress = readProgress(config);
+    const lines = progress.split("\n").length;
+    logger.success(`  ${config.progress.file} found (${lines} lines)`);
+  } else {
+    logger.warning(`  ${config.progress.file} not found`);
+  }
+  logger.newline();
+  logger.bold("Prerequisites:");
+  const ghAuth = await checkGhAuth();
+  if (ghAuth) {
+    logger.success("  GitHub CLI authenticated");
+  } else {
+    logger.error("  GitHub CLI not authenticated");
+  }
+  const claudeOk = await checkClaudeCli();
+  if (claudeOk) {
+    logger.success("  Claude CLI available");
+  } else {
+    logger.error("  Claude CLI not found");
+  }
+  logger.newline();
+  logger.bold("Git Status:");
+  const currentBranch = await getCurrentBranch();
+  const onMain = await isOnMainBranch();
+  const uncommitted = await hasUncommittedChanges();
+  const baseBranch = await getDefaultBranch();
+  logger.info(`  Branch: ${colors.branch(currentBranch)}`);
+  if (onMain) {
+    logger.info("  On main branch - ready to start new work");
+  } else {
+    const branchInfo = parseBranchName(currentBranch);
+    if (branchInfo) {
+      logger.info(`  Issue: ${colors.issue(`#${branchInfo.issueNumber}`)}`);
+      logger.info(`  Type: ${branchInfo.type}`);
+    }
+    const commits = await getCommitsSinceBase(baseBranch);
+    logger.info(`  Commits ahead of ${baseBranch}: ${commits.length}`);
+    const unpushed = await getUnpushedCommits();
+    if (unpushed) {
+      logger.warning("  Has unpushed commits");
+    } else {
+      logger.success("  Up to date with remote");
+    }
+  }
+  if (uncommitted) {
+    logger.warning("  Has uncommitted changes");
+  }
+  logger.newline();
+  if (!onMain) {
+    const issueNumber = extractIssueNumber(currentBranch);
+    if (issueNumber) {
+      logger.bold("Linked Issue:");
+      try {
+        const issue = await getIssue(issueNumber);
+        logger.info(`  #${issue.number}: ${issue.title}`);
+        logger.info(`  State: ${issue.state}`);
+        logger.info(`  Labels: ${issue.labels.join(", ")}`);
+        if (issue.labels.includes(workflowLabels.ready)) {
+          logger.info(`  Workflow: ${colors.label("ai-ready")}`);
+        } else if (issue.labels.includes(workflowLabels.inProgress)) {
+          logger.info(`  Workflow: ${colors.label("ai-in-progress")}`);
+        } else if (issue.labels.includes(workflowLabels.completed)) {
+          logger.info(`  Workflow: ${colors.label("ai-completed")}`);
+        } else if (issue.labels.includes(workflowLabels.blocked)) {
+          logger.info(`  Workflow: ${colors.label("ai-blocked")}`);
+        }
+      } catch {
+        logger.warning(`  Could not fetch issue #${issueNumber}`);
+      }
+      logger.newline();
+    }
+    logger.bold("Pull Request:");
+    const pr = await getPrForBranch();
+    if (pr) {
+      logger.success(`  PR #${pr.number} exists`);
+      logger.info(`  ${colors.url(pr.url)}`);
+    } else {
+      logger.info("  No PR created yet");
+      logger.dim(`  Run ${colors.command("gent pr")} to create one`);
+    }
+    logger.newline();
+  }
+  logger.bold("Suggested Actions:");
+  if (onMain) {
+    logger.list([
+      `${colors.command("gent list")} - View ai-ready issues`,
+      `${colors.command("gent run --auto")} - Start working on highest priority issue`,
+      `${colors.command("gent create <description>")} - Create a new ticket`
+    ]);
+  } else {
+    const pr = await getPrForBranch();
+    if (!pr) {
+      logger.list([
+        `${colors.command("gent pr")} - Create a pull request`,
+        `${colors.command("git push")} - Push your changes`
+      ]);
+    } else {
+      logger.list([
+        `Review and merge your PR`,
+        `${colors.command("git checkout main")} - Return to main branch`
+      ]);
+    }
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("gent").description("AI-powered GitHub workflow CLI - leverage Claude AI to create tickets, implement features, and manage PRs").version("0.1.0");
+program.command("init").description("Initialize gent workflow in current repository").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
+  await initCommand(options);
+});
+program.command("setup-labels").description("Setup GitHub labels for AI workflow").action(async () => {
+  await setupLabelsCommand();
+});
+program.command("create <description>").description("Create an AI-enhanced GitHub issue").action(async (description) => {
+  await createCommand(description);
+});
+program.command("list").description("List GitHub issues by label/status").option("-l, --label <label>", "Filter by label").option("-s, --status <status>", "Filter by workflow status (ready, in-progress, completed, blocked, all)").option("-n, --limit <number>", "Maximum number of issues to show", "20").action(async (options) => {
+  await listCommand({
+    label: options.label,
+    status: options.status,
+    limit: parseInt(options.limit, 10)
+  });
+});
+program.command("run [issue-number]").description("Run Claude to implement a GitHub issue").option("-a, --auto", "Auto-select highest priority ai-ready issue").action(async (issueNumber, options) => {
+  await runCommand(issueNumber, { auto: options.auto });
+});
+program.command("pr").description("Create an AI-enhanced pull request").option("-d, --draft", "Create as draft PR").action(async (options) => {
+  await prCommand({ draft: options.draft });
+});
+program.command("status").description("Show current workflow status").action(async () => {
+  await statusCommand();
+});
+program.parse();
+//# sourceMappingURL=index.js.map