@rotorsoft/gent 1.0.0

package/dist/chunk-NRTQPDZB.js

@@ -0,0 +1,667 @@
+#!/usr/bin/env node
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => console.log(chalk.blue("\u2139"), message),
+  success: (message) => console.log(chalk.green("\u2713"), message),
+  warning: (message) => console.log(chalk.yellow("\u26A0"), message),
+  error: (message) => console.log(chalk.red("\u2717"), message),
+  debug: (message) => {
+    if (process.env.DEBUG) {
+      console.log(chalk.gray("\u22EF"), message);
+    }
+  },
+  dim: (message) => console.log(chalk.dim(message)),
+  bold: (message) => console.log(chalk.bold(message)),
+  highlight: (message) => console.log(chalk.cyan(message)),
+  box: (title, content) => {
+    const lines = content.split("\n");
+    const maxLen = Math.max(title.length, ...lines.map((l) => l.length)) + 4;
+    const border = "\u2500".repeat(maxLen);
+    console.log(chalk.dim(`\u250C${border}\u2510`));
+    console.log(chalk.dim("\u2502"), chalk.bold(title.padEnd(maxLen - 2)), chalk.dim("\u2502"));
+    console.log(chalk.dim(`\u251C${border}\u2524`));
+    for (const line of lines) {
+      console.log(chalk.dim("\u2502"), line.padEnd(maxLen - 2), chalk.dim("\u2502"));
+    }
+    console.log(chalk.dim(`\u2514${border}\u2518`));
+  },
+  list: (items, bullet = "\u2022") => {
+    for (const item of items) {
+      console.log(chalk.dim(bullet), item);
+    }
+  },
+  newline: () => console.log()
+};
+var colors = {
+  issue: chalk.cyan,
+  branch: chalk.magenta,
+  label: chalk.yellow,
+  file: chalk.green,
+  command: chalk.blue,
+  url: chalk.underline.blue
+};
+
+// src/utils/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text,
+    spinner: "dots"
+  });
+}
+async function withSpinner(text, fn) {
+  const spinner = createSpinner(text);
+  spinner.start();
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+
+// src/lib/config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+var DEFAULT_CONFIG = {
+  version: 1,
+  github: {
+    labels: {
+      workflow: {
+        ready: "ai-ready",
+        in_progress: "ai-in-progress",
+        completed: "ai-completed",
+        blocked: "ai-blocked"
+      },
+      types: ["feature", "fix", "refactor", "chore", "docs", "test"],
+      priorities: ["critical", "high", "medium", "low"],
+      risks: ["low", "medium", "high"],
+      areas: ["ui", "api", "database", "workers", "shared", "testing", "infra"]
+    }
+  },
+  branch: {
+    pattern: "{author}/{type}-{issue}-{slug}",
+    author_source: "git",
+    author_env_var: "GENT_AUTHOR"
+  },
+  progress: {
+    file: "progress.txt",
+    archive_threshold: 500,
+    archive_dir: ".gent/archive"
+  },
+  claude: {
+    permission_mode: "acceptEdits",
+    agent_file: "AGENT.md"
+  },
+  validation: ["npm run typecheck", "npm run lint", "npm run test"]
+};
+function getConfigPath(cwd = process.cwd()) {
+  return join(cwd, ".gent.yml");
+}
+function getAgentPath(cwd = process.cwd()) {
+  const config = loadConfig(cwd);
+  const agentPath = join(cwd, config.claude.agent_file);
+  return existsSync(agentPath) ? agentPath : null;
+}
+function loadConfig(cwd = process.cwd()) {
+  const configPath = getConfigPath(cwd);
+  if (!existsSync(configPath)) {
+    return DEFAULT_CONFIG;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const userConfig = parseYaml(content);
+    return mergeConfig(DEFAULT_CONFIG, userConfig);
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+function loadAgentInstructions(cwd = process.cwd()) {
+  const agentPath = getAgentPath(cwd);
+  if (!agentPath) {
+    return null;
+  }
+  try {
+    return readFileSync(agentPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function configExists(cwd = process.cwd()) {
+  return existsSync(getConfigPath(cwd));
+}
+function mergeConfig(defaults, user) {
+  return {
+    version: user.version ?? defaults.version,
+    github: {
+      labels: {
+        workflow: {
+          ...defaults.github.labels.workflow,
+          ...user.github?.labels?.workflow
+        },
+        types: user.github?.labels?.types ?? defaults.github.labels.types,
+        priorities: user.github?.labels?.priorities ?? defaults.github.labels.priorities,
+        risks: user.github?.labels?.risks ?? defaults.github.labels.risks,
+        areas: user.github?.labels?.areas ?? defaults.github.labels.areas
+      }
+    },
+    branch: {
+      ...defaults.branch,
+      ...user.branch
+    },
+    progress: {
+      ...defaults.progress,
+      ...user.progress
+    },
+    claude: {
+      ...defaults.claude,
+      ...user.claude
+    },
+    validation: user.validation ?? defaults.validation
+  };
+}
+function generateDefaultConfig() {
+  return `# Gent Configuration
+# See https://github.com/rotorsoft/gent for documentation
+version: 1
+
+# GitHub settings
+github:
+  labels:
+    workflow:
+      ready: "ai-ready"
+      in_progress: "ai-in-progress"
+      completed: "ai-completed"
+      blocked: "ai-blocked"
+    types:
+      - feature
+      - fix
+      - refactor
+      - chore
+      - docs
+      - test
+    priorities:
+      - critical
+      - high
+      - medium
+      - low
+    risks:
+      - low
+      - medium
+      - high
+    areas:
+      - ui
+      - api
+      - database
+      - workers
+      - shared
+      - testing
+      - infra
+
+# Branch naming convention
+branch:
+  pattern: "{author}/{type}-{issue}-{slug}"
+  author_source: "git"  # git | env | prompt
+  author_env_var: "GENT_AUTHOR"
+
+# Progress tracking
+progress:
+  file: "progress.txt"
+  archive_threshold: 500
+  archive_dir: ".gent/archive"
+
+# Claude settings
+claude:
+  permission_mode: "acceptEdits"
+  agent_file: "AGENT.md"
+
+# Validation commands (run before commit)
+validation:
+  - "npm run typecheck"
+  - "npm run lint"
+  - "npm run test"
+`;
+}
+
+// src/types/index.ts
+var DEFAULT_LABELS = {
+  workflow: [
+    {
+      name: "ai-ready",
+      color: "0E8A16",
+      description: "Issue ready for AI implementation"
+    },
+    {
+      name: "ai-in-progress",
+      color: "FFA500",
+      description: "AI currently working on this"
+    },
+    {
+      name: "ai-completed",
+      color: "1D76DB",
+      description: "AI done, needs human review"
+    },
+    {
+      name: "ai-blocked",
+      color: "D93F0B",
+      description: "AI couldn't complete, needs help"
+    }
+  ],
+  priority: [
+    {
+      name: "priority:critical",
+      color: "B60205",
+      description: "Blocking production"
+    },
+    {
+      name: "priority:high",
+      color: "D93F0B",
+      description: "Important features/bugs"
+    },
+    {
+      name: "priority:medium",
+      color: "FBCA04",
+      description: "Nice-to-have improvements"
+    },
+    { name: "priority:low", color: "0E8A16", description: "Minor tweaks" }
+  ],
+  risk: [
+    {
+      name: "risk:low",
+      color: "C2E0C6",
+      description: "UI changes, tests, non-critical"
+    },
+    {
+      name: "risk:medium",
+      color: "FEF2C0",
+      description: "API changes, new features"
+    },
+    {
+      name: "risk:high",
+      color: "F9D0C4",
+      description: "Migrations, auth, security"
+    }
+  ],
+  type: [
+    { name: "type:feature", color: "1D76DB", description: "New feature" },
+    { name: "type:fix", color: "D73A4A", description: "Bug fix" },
+    {
+      name: "type:refactor",
+      color: "5319E7",
+      description: "Code improvement"
+    },
+    { name: "type:chore", color: "FEF2C0", description: "Maintenance" },
+    { name: "type:docs", color: "0075CA", description: "Documentation" },
+    { name: "type:test", color: "D4C5F9", description: "Testing" }
+  ],
+  area: [
+    { name: "area:ui", color: "C5DEF5", description: "User interface" },
+    { name: "area:api", color: "D4C5F9", description: "API/Backend" },
+    { name: "area:database", color: "FEF2C0", description: "Database/Models" },
+    {
+      name: "area:workers",
+      color: "F9D0C4",
+      description: "Background workers"
+    },
+    { name: "area:shared", color: "C2E0C6", description: "Shared libraries" },
+    { name: "area:testing", color: "E99695", description: "Test infrastructure" },
+    { name: "area:infra", color: "BFD4F2", description: "Infrastructure/DevOps" }
+  ]
+};
+
+// src/lib/labels.ts
+function getAllLabels(config) {
+  const labels = [];
+  labels.push(...DEFAULT_LABELS.workflow);
+  for (const priority of config.github.labels.priorities) {
+    const defaultLabel = DEFAULT_LABELS.priority.find(
+      (l) => l.name === `priority:${priority}`
+    );
+    if (defaultLabel) {
+      labels.push(defaultLabel);
+    } else {
+      labels.push({
+        name: `priority:${priority}`,
+        color: "FBCA04",
+        description: `Priority: ${priority}`
+      });
+    }
+  }
+  for (const risk of config.github.labels.risks) {
+    const defaultLabel = DEFAULT_LABELS.risk.find(
+      (l) => l.name === `risk:${risk}`
+    );
+    if (defaultLabel) {
+      labels.push(defaultLabel);
+    } else {
+      labels.push({
+        name: `risk:${risk}`,
+        color: "FEF2C0",
+        description: `Risk: ${risk}`
+      });
+    }
+  }
+  for (const type of config.github.labels.types) {
+    const defaultLabel = DEFAULT_LABELS.type.find(
+      (l) => l.name === `type:${type}`
+    );
+    if (defaultLabel) {
+      labels.push(defaultLabel);
+    } else {
+      labels.push({
+        name: `type:${type}`,
+        color: "1D76DB",
+        description: `Type: ${type}`
+      });
+    }
+  }
+  for (const area of config.github.labels.areas) {
+    const defaultLabel = DEFAULT_LABELS.area.find(
+      (l) => l.name === `area:${area}`
+    );
+    if (defaultLabel) {
+      labels.push(defaultLabel);
+    } else {
+      labels.push({
+        name: `area:${area}`,
+        color: "C5DEF5",
+        description: `Area: ${area}`
+      });
+    }
+  }
+  return labels;
+}
+function getWorkflowLabels(config) {
+  return {
+    ready: config.github.labels.workflow.ready,
+    inProgress: config.github.labels.workflow.in_progress,
+    completed: config.github.labels.workflow.completed,
+    blocked: config.github.labels.workflow.blocked
+  };
+}
+function buildIssueLabels(meta) {
+  return [
+    "ai-ready",
+    `type:${meta.type}`,
+    `priority:${meta.priority}`,
+    `risk:${meta.risk}`,
+    `area:${meta.area}`
+  ];
+}
+function extractTypeFromLabels(labels) {
+  for (const label of labels) {
+    if (label.startsWith("type:")) {
+      return label.replace("type:", "");
+    }
+  }
+  return "feature";
+}
+function extractPriorityFromLabels(labels) {
+  for (const label of labels) {
+    if (label.startsWith("priority:")) {
+      return label.replace("priority:", "");
+    }
+  }
+  return "medium";
+}
+function sortByPriority(issues) {
+  const priorityOrder = ["critical", "high", "medium", "low"];
+  issues.sort((a, b) => {
+    const aPriority = extractPriorityFromLabels(a.labels);
+    const bPriority = extractPriorityFromLabels(b.labels);
+    return priorityOrder.indexOf(aPriority) - priorityOrder.indexOf(bPriority);
+  });
+}
+
+// src/lib/github.ts
+import { execa } from "execa";
+async function getIssue(issueNumber) {
+  const { stdout } = await execa("gh", [
+    "issue",
+    "view",
+    String(issueNumber),
+    "--json",
+    "number,title,body,labels,state,assignees,url"
+  ]);
+  const data = JSON.parse(stdout);
+  return {
+    number: data.number,
+    title: data.title,
+    body: data.body || "",
+    labels: data.labels.map((l) => l.name),
+    state: data.state.toLowerCase(),
+    assignee: data.assignees?.[0]?.login,
+    url: data.url
+  };
+}
+async function listIssues(options) {
+  const args = ["issue", "list", "--json", "number,title,body,labels,state,url"];
+  if (options.labels?.length) {
+    args.push("--label", options.labels.join(","));
+  }
+  if (options.state) {
+    args.push("--state", options.state);
+  }
+  args.push("--limit", String(options.limit || 50));
+  const { stdout } = await execa("gh", args);
+  const data = JSON.parse(stdout);
+  return data.map(
+    (d) => ({
+      number: d.number,
+      title: d.title,
+      body: d.body || "",
+      labels: d.labels.map((l) => l.name),
+      state: d.state.toLowerCase(),
+      url: d.url
+    })
+  );
+}
+async function createIssue(options) {
+  const args = ["issue", "create", "--title", options.title, "--body", options.body];
+  if (options.labels?.length) {
+    args.push("--label", options.labels.join(","));
+  }
+  const { stdout } = await execa("gh", args);
+  const match = stdout.match(/\/issues\/(\d+)/);
+  if (!match) {
+    throw new Error("Failed to extract issue number from gh output");
+  }
+  return parseInt(match[1], 10);
+}
+async function updateIssueLabels(issueNumber, options) {
+  const promises = [];
+  if (options.add?.length) {
+    promises.push(
+      execa("gh", [
+        "issue",
+        "edit",
+        String(issueNumber),
+        "--add-label",
+        options.add.join(",")
+      ])
+    );
+  }
+  if (options.remove?.length) {
+    promises.push(
+      execa("gh", [
+        "issue",
+        "edit",
+        String(issueNumber),
+        "--remove-label",
+        options.remove.join(",")
+      ])
+    );
+  }
+  await Promise.all(promises);
+}
+async function addIssueComment(issueNumber, body) {
+  await execa("gh", ["issue", "comment", String(issueNumber), "--body", body]);
+}
+async function assignIssue(issueNumber, assignee) {
+  await execa("gh", [
+    "issue",
+    "edit",
+    String(issueNumber),
+    "--add-assignee",
+    assignee
+  ]);
+}
+async function createLabel(label) {
+  try {
+    await execa("gh", [
+      "label",
+      "create",
+      label.name,
+      "--color",
+      label.color,
+      "--description",
+      label.description || "",
+      "--force"
+    ]);
+  } catch {
+  }
+}
+async function createPullRequest(options) {
+  const args = [
+    "pr",
+    "create",
+    "--title",
+    options.title,
+    "--body",
+    options.body,
+    "--assignee",
+    "@me"
+  ];
+  if (options.base) {
+    args.push("--base", options.base);
+  }
+  if (options.draft) {
+    args.push("--draft");
+  }
+  const { stdout } = await execa("gh", args);
+  return stdout.trim();
+}
+async function getPrForBranch() {
+  try {
+    const { stdout } = await execa("gh", [
+      "pr",
+      "view",
+      "--json",
+      "number,url"
+    ]);
+    const data = JSON.parse(stdout);
+    return { number: data.number, url: data.url };
+  } catch {
+    return null;
+  }
+}
+async function getCurrentUser() {
+  const { stdout } = await execa("gh", ["api", "user", "--jq", ".login"]);
+  return stdout.trim();
+}
+
+// src/utils/validators.ts
+import { execa as execa2 } from "execa";
+async function checkGhAuth() {
+  try {
+    await execa2("gh", ["auth", "status"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkClaudeCli() {
+  try {
+    await execa2("claude", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkGitRepo() {
+  try {
+    await execa2("git", ["rev-parse", "--git-dir"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIssueNumber(value) {
+  const num = parseInt(value, 10);
+  return !isNaN(num) && num > 0;
+}
+function sanitizeSlug(title, maxLength = 40) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLength);
+}
+
+// src/commands/setup-labels.ts
+async function setupLabelsCommand() {
+  logger.bold("Setting up GitHub labels...");
+  logger.newline();
+  const isAuthed = await checkGhAuth();
+  if (!isAuthed) {
+    logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const labels = getAllLabels(config);
+  logger.info(`Creating ${labels.length} labels...`);
+  logger.newline();
+  let created = 0;
+  let failed = 0;
+  for (const label of labels) {
+    try {
+      await withSpinner(`Creating ${colors.label(label.name)}`, async () => {
+        await createLabel(label);
+      });
+      created++;
+    } catch (error) {
+      logger.error(`Failed to create ${label.name}: ${error}`);
+      failed++;
+    }
+  }
+  logger.newline();
+  logger.success(`Created ${created} labels`);
+  if (failed > 0) {
+    logger.warning(`Failed to create ${failed} labels`);
+  }
+  logger.newline();
+  logger.info("Labels are ready. You can now create AI-ready issues.");
+}
+
+export {
+  logger,
+  colors,
+  checkGhAuth,
+  checkClaudeCli,
+  checkGitRepo,
+  isValidIssueNumber,
+  sanitizeSlug,
+  getConfigPath,
+  loadConfig,
+  loadAgentInstructions,
+  configExists,
+  generateDefaultConfig,
+  withSpinner,
+  getWorkflowLabels,
+  buildIssueLabels,
+  extractTypeFromLabels,
+  extractPriorityFromLabels,
+  sortByPriority,
+  getIssue,
+  listIssues,
+  createIssue,
+  updateIssueLabels,
+  addIssueComment,
+  assignIssue,
+  createPullRequest,
+  getPrForBranch,
+  getCurrentUser,
+  setupLabelsCommand
+};
+//# sourceMappingURL=chunk-NRTQPDZB.js.map