@ulpi/cli 0.1.5 → 0.1.6

package/dist/prd-Q4J5NVAR.js

@@ -0,0 +1,408 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/prd.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+async function runPrd(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create":
+      return await createSubcommand(args.slice(1), projectDir);
+    case "convert":
+      return await convertSubcommand(args.slice(1), projectDir);
+    case "show":
+      return await showSubcommand(args.slice(1), projectDir);
+    default:
+      console.log(`
+Usage: ulpi prd <subcommand> [options]
+
+Subcommands:
+  create [file] [--chat]     Create or parse a PRD
+  convert <file> [--output]  Convert markdown PRD to JSON tasks
+  show <file>                Show parsed PRD summary
+
+Options:
+  --chat              Interactive AI mode for PRD creation
+  --agent <name>      AI agent to use (default: claude)
+  --model <id>        Model override for the agent
+  --output, -o        Output file path for conversion
+  --prefix            Task ID prefix (default: "TASK-")
+`.trim());
+  }
+}
+async function createSubcommand(args, projectDir) {
+  const isChat = args.includes("--chat");
+  const fileArg = args.find((a) => !a.startsWith("--"));
+  if (isChat) {
+    return await runChatMode(args, projectDir);
+  }
+  if (!fileArg) {
+    console.log(chalk.yellow("Provide a markdown file to parse, or use --chat for interactive mode."));
+    console.log(chalk.dim("  ulpi prd create <file.md>"));
+    console.log(chalk.dim("  ulpi prd create --chat"));
+    return;
+  }
+  const filePath = path.isAbsolute(fileArg) ? fileArg : path.resolve(projectDir, fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const markdown = fs.readFileSync(filePath, "utf-8");
+  const { parsePrdMarkdown } = await import("./dist-3EIQTZHT.js");
+  const result = parsePrdMarkdown(markdown);
+  console.log(chalk.bold(`
+PRD: ${result.document.title}
+`));
+  console.log(chalk.dim(`Description: ${result.document.description}
+`));
+  if (result.document.tasks.length > 0) {
+    console.log(chalk.bold(`Tasks (${result.document.tasks.length}):`));
+    for (const task of result.document.tasks) {
+      const priorityColor = task.priority <= 1 ? "red" : task.priority <= 2 ? "yellow" : "green";
+      const priorityStr = chalk[priorityColor](`P${task.priority}`);
+      console.log(`  ${chalk.cyan(task.id)} ${task.title} ${priorityStr}`);
+      if (task.acceptanceCriteria.length > 0) {
+        console.log(chalk.dim(`    ${task.acceptanceCriteria.length} acceptance criteria`));
+      }
+      if (task.dependsOn.length > 0) {
+        console.log(chalk.dim(`    depends on: ${task.dependsOn.join(", ")}`));
+      }
+    }
+  } else {
+    console.log(chalk.yellow("No tasks found in PRD."));
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk.yellow(`
+Warnings (${result.warnings.length}):`));
+    for (const warning of result.warnings) {
+      console.log(chalk.yellow(`  - ${warning}`));
+    }
+  }
+  console.log("");
+}
+async function convertSubcommand(args, projectDir) {
+  const fileArg = args.find((a) => !a.startsWith("--") && !a.startsWith("-"));
+  const outputIdx = args.findIndex((a) => a === "--output" || a === "-o");
+  const outputArg = outputIdx !== -1 ? args[outputIdx + 1] : void 0;
+  const prefixIdx = args.findIndex((a) => a === "--prefix");
+  const prefix = prefixIdx !== -1 ? args[prefixIdx + 1] : void 0;
+  if (!fileArg) {
+    console.error(chalk.red("Provide a markdown PRD file to convert."));
+    console.log(chalk.dim("  ulpi prd convert <file.md> [--output tasks.json]"));
+    process.exit(1);
+  }
+  const filePath = path.isAbsolute(fileArg) ? fileArg : path.resolve(projectDir, fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const markdown = fs.readFileSync(filePath, "utf-8");
+  const { parsePrdMarkdown, convertPrdToTasks, convertPrdToJson } = await import("./dist-3EIQTZHT.js");
+  const result = parsePrdMarkdown(markdown, { taskPrefix: prefix });
+  if (result.document.tasks.length === 0) {
+    console.error(chalk.red("No tasks found in PRD. Cannot convert."));
+    if (result.warnings.length > 0) {
+      for (const warning of result.warnings) {
+        console.error(chalk.yellow(`  - ${warning}`));
+      }
+    }
+    process.exit(1);
+  }
+  const tasks = convertPrdToTasks(result.document, true);
+  const jsonOutput = convertPrdToJson(result.document);
+  const outputPath = outputArg ? path.isAbsolute(outputArg) ? outputArg : path.resolve(projectDir, outputArg) : path.resolve(projectDir, ".ulpi", "prds", `${path.basename(filePath, path.extname(filePath))}.json`);
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  fs.writeFileSync(outputPath, JSON.stringify(jsonOutput, null, 2) + "\n", "utf-8");
+  console.log(chalk.green(`Converted ${tasks.length} tasks to: ${outputPath}`));
+  for (const task of tasks) {
+    console.log(chalk.dim(`  ${task.id}: ${task.title} (P${task.priority})`));
+  }
+}
+async function showSubcommand(args, projectDir) {
+  const fileArg = args.find((a) => !a.startsWith("--"));
+  if (!fileArg) {
+    console.error(chalk.red("Provide a markdown PRD file to show."));
+    console.log(chalk.dim("  ulpi prd show <file.md>"));
+    process.exit(1);
+  }
+  const filePath = path.isAbsolute(fileArg) ? fileArg : path.resolve(projectDir, fileArg);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const markdown = fs.readFileSync(filePath, "utf-8");
+  const { parsePrdMarkdown } = await import("./dist-3EIQTZHT.js");
+  const result = parsePrdMarkdown(markdown);
+  const doc = result.document;
+  console.log(chalk.bold(`
+${doc.title}`));
+  console.log(chalk.dim("=".repeat(doc.title.length)));
+  console.log("");
+  if (doc.metadata.branchName) {
+    console.log(`Branch: ${chalk.cyan(String(doc.metadata.branchName))}`);
+  }
+  if (doc.metadata.createdAt) {
+    console.log(`Created: ${chalk.dim(String(doc.metadata.createdAt))}`);
+  }
+  console.log("");
+  console.log(doc.description);
+  console.log("");
+  if (doc.sections.length > 0) {
+    console.log(chalk.bold("Sections:"));
+    for (const section of doc.sections) {
+      const indent = "  ".repeat(Math.max(0, section.level - 1));
+      console.log(`${indent}${"#".repeat(section.level)} ${section.heading}`);
+    }
+    console.log("");
+  }
+  if (doc.tasks.length > 0) {
+    console.log(chalk.bold(`Tasks (${doc.tasks.length}):`));
+    console.log("");
+    for (const task of doc.tasks) {
+      const priorityColor = task.priority <= 1 ? "red" : task.priority <= 2 ? "yellow" : "green";
+      console.log(`  ${chalk.bold.cyan(task.id)}: ${chalk.bold(task.title)} ${chalk[priorityColor](`P${task.priority}`)}`);
+      if (task.description !== task.title) {
+        console.log(chalk.dim(`    ${task.description.slice(0, 120)}${task.description.length > 120 ? "..." : ""}`));
+      }
+      if (task.acceptanceCriteria.length > 0) {
+        console.log(`    ${chalk.dim("Criteria:")} ${task.acceptanceCriteria.length} items`);
+        for (const ac of task.acceptanceCriteria.slice(0, 3)) {
+          console.log(chalk.dim(`      - ${ac}`));
+        }
+        if (task.acceptanceCriteria.length > 3) {
+          console.log(chalk.dim(`      ... and ${task.acceptanceCriteria.length - 3} more`));
+        }
+      }
+      if (task.dependsOn.length > 0) {
+        console.log(`    ${chalk.dim("Depends on:")} ${task.dependsOn.join(", ")}`);
+      }
+      if (task.labels.length > 0) {
+        console.log(`    ${chalk.dim("Labels:")} ${task.labels.map((l) => `[${l}]`).join(" ")}`);
+      }
+      console.log("");
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk.yellow(`Warnings (${result.warnings.length}):`));
+    for (const warning of result.warnings) {
+      console.log(chalk.yellow(`  - ${warning}`));
+    }
+    console.log("");
+  }
+}
+async function runChatMode(args, projectDir) {
+  console.log(chalk.bold("\n  PRD Generator -- AI-Powered\n"));
+  console.log(chalk.dim("  Describe a feature and the AI will help you build a structured PRD."));
+  console.log(chalk.dim("  Type 'quit' or press Ctrl+C to exit.\n"));
+  const agentIdx = args.findIndex((a) => a === "--agent");
+  const agentName = agentIdx !== -1 && args[agentIdx + 1] ? args[agentIdx + 1] : "claude";
+  const modelIdx = args.findIndex((a) => a === "--model");
+  const model = modelIdx !== -1 && args[modelIdx + 1] ? args[modelIdx + 1] : "";
+  const {
+    getPrdSystemPrompt,
+    buildConversationPrompt,
+    detectPrd,
+    parsePrdMarkdown,
+    slugify
+  } = await import("./dist-3EIQTZHT.js");
+  const { getAgentRegistry } = await import("./dist-7QOEYLFX.js");
+  const readline = await import("readline/promises");
+  const registry = getAgentRegistry();
+  await registry.initialize();
+  if (!registry.hasPlugin(agentName)) {
+    console.error(chalk.red(`Unknown agent: ${agentName}`));
+    console.log(chalk.dim(`Available agents: ${registry.getRegisteredPlugins().map((p) => p.name).join(", ")}`));
+    return;
+  }
+  const plugin = await registry.getInstance({
+    name: `prd-chat-${agentName}`,
+    plugin: agentName,
+    options: model ? { model } : {}
+  });
+  const detection = await plugin.detect();
+  if (!detection.available) {
+    console.error(chalk.red(`Agent ${agentName} is not available: ${detection.error ?? "not found in PATH"}`));
+    return;
+  }
+  console.log(chalk.dim(`  Agent: ${agentName}${model ? ` (model: ${model})` : ""}${detection.executablePath ? ` (${detection.executablePath})` : ""}`));
+  console.log("");
+  const history = [];
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.on("close", () => {
+    console.log(chalk.yellow("\n  PRD creation cancelled."));
+  });
+  try {
+    while (true) {
+      let userInput;
+      try {
+        userInput = await rl.question(chalk.cyan("  You: "));
+      } catch {
+        break;
+      }
+      const trimmed = userInput.trim();
+      if (!trimmed) continue;
+      if (trimmed.toLowerCase() === "quit" || trimmed.toLowerCase() === "exit") {
+        console.log(chalk.dim("\n  Goodbye!"));
+        break;
+      }
+      history.push({
+        role: "user",
+        content: trimmed,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      const prompt = buildConversationPrompt(history, trimmed);
+      process.stdout.write(chalk.dim("  AI: thinking..."));
+      try {
+        let responseText = "";
+        const handle = plugin.execute(prompt, {
+          cwd: projectDir,
+          timeout: 12e4,
+          onStdout: (data) => {
+            responseText += data;
+          }
+        });
+        const result = await handle.promise;
+        process.stdout.write("\r" + " ".repeat(40) + "\r");
+        if (result.status !== "completed") {
+          const errorDetail = result.error ?? result.stderr?.slice(0, 200) ?? "unknown error";
+          console.log(chalk.red(`  AI: Error - ${errorDetail}`));
+          history.pop();
+          continue;
+        }
+        const aiResponse = extractTextFromAgentOutput(responseText);
+        if (!aiResponse.trim()) {
+          console.log(chalk.red("  AI: (empty response)"));
+          history.pop();
+          continue;
+        }
+        history.push({
+          role: "assistant",
+          content: aiResponse,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const lines = aiResponse.split("\n");
+        console.log(chalk.white(`  AI: ${lines[0]}`));
+        for (const line of lines.slice(1)) {
+          console.log(chalk.white(`      ${line}`));
+        }
+        console.log("");
+        const prdDetection = detectPrd(aiResponse);
+        if (prdDetection.found && prdDetection.content) {
+          const parsed = parsePrdMarkdown(prdDetection.content);
+          const doc = parsed.document;
+          console.log(chalk.green.bold("  PRD detected!"));
+          console.log(chalk.green(`  Title: ${doc.title}`));
+          console.log(chalk.green(`  Tasks: ${doc.tasks.length}`));
+          if (doc.tasks.length > 0) {
+            for (const task of doc.tasks) {
+              const priorityColor = task.priority <= 1 ? "red" : task.priority <= 2 ? "yellow" : "green";
+              console.log(`    ${chalk.cyan(task.id)} ${task.title} ${chalk[priorityColor](`P${task.priority}`)}`);
+            }
+          }
+          console.log("");
+          let saveAnswer;
+          try {
+            saveAnswer = await rl.question(chalk.cyan("  Save this PRD? [Y/n] "));
+          } catch {
+            break;
+          }
+          if (saveAnswer.trim().toLowerCase() !== "n") {
+            const slug = slugify(doc.title || "untitled");
+            const filename = `prd-${slug}.md`;
+            const prdsDir = path.join(projectDir, ".ulpi", "prds");
+            if (!fs.existsSync(prdsDir)) {
+              fs.mkdirSync(prdsDir, { recursive: true });
+            }
+            const outputPath = path.join(prdsDir, filename);
+            fs.writeFileSync(outputPath, prdDetection.content, "utf-8");
+            console.log(chalk.green(`  Saved to: ${outputPath}`));
+            console.log("");
+            let runAnswer;
+            try {
+              runAnswer = await rl.question(chalk.cyan("  Run this PRD? [y/N] "));
+            } catch {
+              break;
+            }
+            if (runAnswer.trim().toLowerCase() === "y") {
+              const modelArgs = model ? ` --model ${model}` : "";
+              console.log(chalk.dim(`
+  Starting: ulpi run --prd ${outputPath} --agent ${agentName}${modelArgs}
+`));
+              rl.close();
+              try {
+                const { runRunCommand } = await import("./run-VPNXEIBY.js");
+                const runArgs = ["--prd", outputPath, "--agent", agentName];
+                if (model) runArgs.push("--model", model);
+                await runRunCommand(runArgs, projectDir);
+              } catch (runErr) {
+                const msg = runErr instanceof Error ? runErr.message : String(runErr);
+                console.error(chalk.red(`  Failed to start run: ${msg}`));
+              }
+              return;
+            }
+          }
+          break;
+        }
+      } catch (err) {
+        process.stdout.write("\r" + " ".repeat(40) + "\r");
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk.red(`  Error: ${message}`));
+        history.pop();
+      }
+    }
+  } finally {
+    try {
+      rl.close();
+    } catch {
+    }
+    try {
+      await registry.disposeInstance(`prd-chat-${agentName}`);
+    } catch {
+    }
+  }
+}
+function extractTextFromAgentOutput(raw) {
+  const lines = raw.split("\n").filter((l) => l.trim());
+  const textParts = [];
+  let isStreamJson = false;
+  for (const line of lines) {
+    try {
+      const parsed = JSON.parse(line);
+      isStreamJson = true;
+      if (parsed.type === "assistant" && parsed.message) {
+        const msg = parsed.message;
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text") {
+              textParts.push(block.text);
+            }
+          }
+        }
+      }
+      if (parsed.type === "content_block_delta") {
+        const delta = parsed.delta;
+        if (delta && delta.type === "text_delta" && typeof delta.text === "string") {
+          textParts.push(delta.text);
+        }
+      }
+      if (parsed.type === "result" && typeof parsed.result === "string") {
+        textParts.push(parsed.result);
+      }
+    } catch {
+      if (!isStreamJson) {
+        textParts.push(line);
+      }
+    }
+  }
+  return textParts.join("").trim() || raw.trim();
+}
+export {
+  runPrd
+};

package/dist/repos-WWZXNN3P.js

@@ -0,0 +1,271 @@
+import {
+  getDefaultRepo,
+  getRepo,
+  listRepos,
+  loadRepoRegistry,
+  registerRepo,
+  scanForRepos,
+  setDefaultRepo,
+  unregisterRepo
+} from "./chunk-UXHCHOWQ.js";
+import {
+  JsonSessionStore
+} from "./chunk-SEU7WWNQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/repos.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+function runRepos(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      listReposCmd();
+      break;
+    case "add":
+      addRepoCmd(args[1]);
+      break;
+    case "remove":
+    case "rm":
+      removeRepoCmd(args[1]);
+      break;
+    case "default":
+      defaultRepoCmd(args[1]);
+      break;
+    case "scan":
+      scanReposCmd(args[1]);
+      break;
+    case "status":
+      statusCmd();
+      break;
+    default:
+      printUsage();
+  }
+}
+function printUsage() {
+  console.log(`
+${chalk.bold("ULPI \u2014 Repo Management")}
+
+Usage: ulpi repos <command>
+
+Commands:
+  list, ls              List all registered repos
+  add <path>            Register a repo
+  remove, rm <id|path>  Unregister a repo
+  default [id|path]     Get/set default repo
+  scan [root-dir]       Discover repos with .ulpi/
+  status                Global health overview
+
+Examples:
+  ulpi repos list
+  ulpi repos add /path/to/my-repo
+  ulpi repos default my-webapp-id
+  ulpi repos scan ~/projects
+`.trim());
+}
+function listReposCmd() {
+  const repos = listRepos();
+  const defaultRepo = getDefaultRepo();
+  if (repos.length === 0) {
+    console.log(chalk.yellow("\nNo repos registered."));
+    console.log("Run 'ulpi repos add <path>' to register a repo.");
+    console.log("Or run 'ulpi init' in a repo directory.\n");
+    return;
+  }
+  console.log(chalk.bold(`
+Repos (${repos.length} registered)
+`));
+  for (const repo of repos) {
+    const isDefault = defaultRepo?.id === repo.id;
+    const prefix = isDefault ? chalk.yellow("\u2605") : " ";
+    const name = chalk.bold(repo.name);
+    const defaultLabel = isDefault ? chalk.dim(" (default)") : "";
+    console.log(`  ${prefix} ${name}${defaultLabel}`);
+    console.log(chalk.dim(`    ${repo.path}`));
+    if (repo.stack) {
+      const stackParts = [];
+      if (repo.stack.runtime) stackParts.push(repo.stack.runtime);
+      if (repo.stack.framework) stackParts.push(repo.stack.framework);
+      if (repo.stack.packageManager) stackParts.push(repo.stack.packageManager);
+      if (stackParts.length > 0) {
+        console.log(chalk.dim(`    Stack: ${stackParts.join(" + ")}`));
+      }
+    }
+    const statusIcon = getStatusIcon(repo);
+    const statusLabel = getStatusLabel(repo);
+    console.log(`    Status: ${statusIcon} ${statusLabel}`);
+    const lastAccessed = formatRelativeTime(repo.lastAccessed);
+    console.log(chalk.dim(`    Last accessed: ${lastAccessed}`));
+    console.log();
+  }
+}
+function addRepoCmd(repoPath) {
+  if (!repoPath) {
+    console.log(chalk.red("Error: Repo path required."));
+    console.log("Usage: ulpi repos add <path>");
+    return;
+  }
+  const absPath = path.resolve(repoPath);
+  if (!fs.existsSync(absPath)) {
+    console.log(chalk.red(`Error: Path does not exist: ${absPath}`));
+    return;
+  }
+  if (!fs.statSync(absPath).isDirectory()) {
+    console.log(chalk.red(`Error: Path is not a directory: ${absPath}`));
+    return;
+  }
+  const entry = registerRepo(absPath);
+  console.log(chalk.green(`Registered: ${entry.name}`));
+  console.log(chalk.dim(`  ID: ${entry.id}`));
+  console.log(chalk.dim(`  Path: ${entry.path}`));
+  console.log(chalk.dim(`  Status: ${getStatusLabel(entry)}`));
+}
+function removeRepoCmd(idOrPath) {
+  if (!idOrPath) {
+    console.log(chalk.red("Error: Repo ID or path required."));
+    console.log("Usage: ulpi repos remove <id|path>");
+    return;
+  }
+  const repo = getRepo(idOrPath);
+  if (!repo) {
+    console.log(chalk.red(`Error: Repo not found: ${idOrPath}`));
+    return;
+  }
+  const removed = unregisterRepo(idOrPath);
+  if (removed) {
+    console.log(chalk.green(`Unregistered: ${repo.name}`));
+  } else {
+    console.log(chalk.red(`Error: Failed to unregister repo.`));
+  }
+}
+function defaultRepoCmd(idOrPath) {
+  if (!idOrPath) {
+    const defaultRepo = getDefaultRepo();
+    if (defaultRepo) {
+      console.log(`Default repo: ${chalk.bold(defaultRepo.name)}`);
+      console.log(chalk.dim(`  ID: ${defaultRepo.id}`));
+      console.log(chalk.dim(`  Path: ${defaultRepo.path}`));
+    } else {
+      console.log(chalk.yellow("No default repo set."));
+      console.log("Use 'ulpi repos default <id|path>' to set one.");
+    }
+    return;
+  }
+  if (idOrPath === "none" || idOrPath === "clear") {
+    setDefaultRepo(void 0);
+    console.log(chalk.green("Default repo cleared."));
+    return;
+  }
+  const repo = getRepo(idOrPath);
+  if (!repo) {
+    console.log(chalk.red(`Error: Repo not found: ${idOrPath}`));
+    return;
+  }
+  const success = setDefaultRepo(repo.id);
+  if (success) {
+    console.log(chalk.green(`Default repo set to: ${repo.name}`));
+  } else {
+    console.log(chalk.red("Error: Failed to set default repo."));
+  }
+}
+function scanReposCmd(rootDir) {
+  const scanRoot = rootDir ? path.resolve(rootDir) : process.cwd();
+  if (!fs.existsSync(scanRoot)) {
+    console.log(chalk.red(`Error: Path does not exist: ${scanRoot}`));
+    return;
+  }
+  console.log(chalk.cyan(`Scanning for repos in: ${scanRoot}
+`));
+  const found = scanForRepos(scanRoot);
+  if (found.length === 0) {
+    console.log(chalk.yellow("No repos with .ulpi/ found."));
+    return;
+  }
+  console.log(`Found ${found.length} repo(s):
+`);
+  for (const repoPath of found) {
+    const existing = getRepo(repoPath);
+    const status = existing ? chalk.dim("(already registered)") : "";
+    console.log(`  ${chalk.green("\u2713")} ${repoPath} ${status}`);
+    if (!existing) {
+      registerRepo(repoPath);
+    }
+  }
+  console.log(chalk.green(`
+All repos registered.`));
+}
+function statusCmd() {
+  const repos = listRepos();
+  const registry = loadRepoRegistry();
+  const store = new JsonSessionStore();
+  console.log(chalk.bold("\nULPI \u2014 Global Status\n"));
+  console.log(chalk.cyan("Summary"));
+  console.log(`  Total repos: ${repos.length}`);
+  const configured = repos.filter((r) => r.configStatus === "configured").length;
+  const withHooks = repos.filter((r) => r.hooksInstalled).length;
+  console.log(`  Configured: ${configured}`);
+  console.log(`  Hooks installed: ${withHooks}`);
+  if (registry.defaultRepo) {
+    const defaultRepo = getRepo(registry.defaultRepo);
+    if (defaultRepo) {
+      console.log(`  Default: ${defaultRepo.name}`);
+    }
+  }
+  const allSessions = store.list();
+  console.log(`  Total sessions: ${allSessions.length}`);
+  console.log();
+  if (repos.length > 0) {
+    console.log(chalk.cyan("Repos"));
+    for (const repo of repos) {
+      const statusIcon = getStatusIcon(repo);
+      const isDefault = registry.defaultRepo === repo.id;
+      const defaultLabel = isDefault ? chalk.yellow(" \u2605") : "";
+      console.log(`  ${statusIcon} ${repo.name}${defaultLabel}`);
+      const repoSessions = store.listByProject(repo.path);
+      if (repoSessions.length > 0) {
+        console.log(chalk.dim(`    Sessions: ${repoSessions.length}`));
+      }
+    }
+  }
+  console.log();
+}
+function getStatusIcon(repo) {
+  if (repo.configStatus === "configured" && repo.hooksInstalled) {
+    return chalk.green("\u2713");
+  }
+  if (repo.configStatus === "configured" || repo.hooksInstalled) {
+    return chalk.yellow("\u26A0");
+  }
+  return chalk.red("\u2717");
+}
+function getStatusLabel(repo) {
+  if (repo.configStatus === "configured" && repo.hooksInstalled) {
+    return chalk.green("Configured");
+  }
+  if (repo.configStatus === "configured" && !repo.hooksInstalled) {
+    return chalk.yellow("Rules configured, hooks not installed");
+  }
+  if (repo.configStatus !== "configured" && repo.hooksInstalled) {
+    return chalk.yellow("Hooks installed, no rules");
+  }
+  return chalk.red("Not configured");
+}
+function formatRelativeTime(isoString) {
+  const date = new Date(isoString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins} minute${diffMins === 1 ? "" : "s"} ago`;
+  if (diffHours < 24) return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  if (diffDays < 7) return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+  return date.toLocaleDateString();
+}
+export {
+  runRepos
+};

package/dist/review-integration-5WHEJU2A.js

@@ -0,0 +1,14 @@
+import {
+  collectPostReviewContexts,
+  extractPlanForReview,
+  isReviewEnabled,
+  runPlanReviewSession
+} from "./chunk-V2H5D6Y3.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  collectPostReviewContexts,
+  extractPlanForReview,
+  isReviewEnabled,
+  runPlanReviewSession
+};