@ulpi/cli 0.1.4 → 0.1.6

package/dist/{init-6CH4HV5T.js → init-5FK3VKRT.js}

@@ -2,24 +2,26 @@ import {
   installGlobalSkill,
   installHooks,
   installLocalSkill
-} from "./chunk-QJ5GSMEC.js";
+} from "./chunk-VVEDXI7E.js";
 import {
-  detectStack
-} from "./chunk-2CLNOKPA.js";
-import {
-  registerProject
-} from "./chunk-SPOI23SB.js";
+  registerRepo
+} from "./chunk-UXHCHOWQ.js";
 import {
   composeTemplates,
   loadBundledTemplates,
   resolveTemplate
-} from "./chunk-6OCEY7JY.js";
+} from "./chunk-4ZPOZULQ.js";
+import {
+  detectStack
+} from "./chunk-RSFJ6QSR.js";
 import {
   DEFAULT_AI_MODEL,
   GUARDS_FILENAME,
   getApiPort,
   projectConfigDir
-} from "./chunk-7LXY5UVC.js";
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-YOKL7RB5.js";
+import "./chunk-KIKPIH6N.js";
 import "./chunk-4VNS5WPM.js";
 
 // src/commands/init.ts
@@ -95,7 +97,7 @@ async function runInit(args) {
     console.log(chalk.yellow(`\u26A0 ${globalResult.message}`));
   }
   try {
-    const { isSupported, isLaunchAgentInstalled, needsLegacyMigration, installLaunchAgent } = await import("./launchd-LF2QMSKZ.js");
+    const { isSupported, isLaunchAgentInstalled, needsLegacyMigration, installLaunchAgent } = await import("./launchd-6AWT54HR.js");
     if (isSupported() && (!isLaunchAgentInstalled() || needsLegacyMigration())) {
       const migrating = needsLegacyMigration();
       installLaunchAgent();
@@ -109,7 +111,7 @@ async function runInit(args) {
   } catch {
   }
   try {
-    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-NQCGKQ23.js");
+    const { installMcpServer, installMemoryMcpServer, installGatewayMcpServer, installMcpForAllClis } = await import("./mcp-installer-PQU3XOGO.js");
     const codemapMcp = installMcpServer(projectDir);
     if (codemapMcp.installed) {
       console.log(chalk.green("\u2713 CodeMap MCP server registered"));
@@ -118,11 +120,40 @@ async function runInit(args) {
     if (memoryMcp.installed) {
       console.log(chalk.green("\u2713 Memory MCP server registered"));
     }
+    const gatewayMcp = installGatewayMcpServer(projectDir);
+    if (gatewayMcp.installed) {
+      console.log(chalk.green("\u2713 MCP Gateway registered"));
+    }
+    const cliResults = installMcpForAllClis(projectDir);
+    for (const result of cliResults) {
+      console.log(chalk.green(`\u2713 ${result.cli} MCP configured (${result.file})`));
+    }
+  } catch {
+  }
+  try {
+    const { execFileSync: execFileSync2 } = await import("child_process");
+    try {
+      execFileSync2("which", ["kiro"], { encoding: "utf-8", timeout: 5e3 });
+      const { installKiroHooks, installKiroSkills } = await import("./dist-6X576SU2.js");
+      const { convertClaudeSkillsToKiro } = await import("./dist-HA74OKJZ.js");
+      const { agent } = installKiroHooks("agent");
+      console.log(chalk.green(`\u2713 Kiro governance agent installed: ${agent}`));
+      const skillCount = installKiroSkills(projectDir);
+      if (skillCount > 0) {
+        console.log(chalk.green(`\u2713 ${skillCount} Kiro bundled skill(s) installed`));
+      }
+      const converted = convertClaudeSkillsToKiro(projectDir);
+      if (converted > 0) {
+        console.log(chalk.green(`\u2713 ${converted} Claude Code skill(s) converted to Kiro format`));
+      }
+      console.log(chalk.dim("  Start Kiro with: kiro --agent ulpi-governance"));
+    } catch {
+    }
   } catch {
   }
   try {
-    const { runInitPipeline } = await import("./dist-CB5D5LMO.js");
-    const { initMemoryBranch } = await import("./dist-GJYT2OQV.js");
+    const { runInitPipeline } = await import("./dist-YFFG2ZD6.js");
+    const { initMemoryBranch } = await import("./dist-JLU26AB6.js");
     console.log(chalk.cyan("\nInitializing code index..."));
     try {
       await runInitPipeline(projectDir, (progress) => {
@@ -143,6 +174,41 @@ async function runInit(args) {
     }
   } catch {
   }
+  try {
+    const { collectProjectSignals } = await import("./dist-EK45QNEM.js");
+    const { suggestMcps, getCatalogEntry, addToLibrary, enableMcp } = await import("./dist-EK45QNEM.js");
+    const signals = collectProjectSignals(projectDir);
+    const suggestions = suggestMcps(signals);
+    const actionable = suggestions.filter((s) => !s.alreadyAdded && (s.confidence === "high" || s.confidence === "medium"));
+    if (actionable.length > 0) {
+      console.log(chalk.cyan("\nDetecting MCP tools for your project..."));
+      let added = 0;
+      for (const suggestion of actionable) {
+        const entry = getCatalogEntry(suggestion.name);
+        if (!entry) continue;
+        addToLibrary(entry.name, {
+          name: entry.name,
+          display_name: entry.display_name,
+          description: entry.description,
+          command: entry.command ?? "npx",
+          args: entry.args ?? [],
+          transport: entry.transport ?? "stdio",
+          category: entry.category ?? "custom",
+          config_schema: entry.config_schema,
+          tags: entry.tags ?? [],
+          source: "catalog"
+        });
+        enableMcp(projectDir, entry.name);
+        console.log(`  ${chalk.green("\u2713")} ${suggestion.displayName} (${suggestion.confidence}) \u2014 ${suggestion.evidence.join(", ")}`);
+        added++;
+      }
+      if (added > 0) {
+        console.log(chalk.dim(`Added ${added} MCP tool(s) to library and enabled for this repo.`));
+        console.log(chalk.dim(`Run 'ulpi mcp status' to see enabled MCPs.`));
+      }
+    }
+  } catch {
+  }
   const config = buildStackConfig(stack, projectDir);
   let generated = false;
   if (!noAi) {
@@ -155,7 +221,7 @@ async function runInit(args) {
     generateFromTemplates(projectDir, rulesPath, stack, config);
   }
   try {
-    registerProject(projectDir, {
+    registerRepo(projectDir, {
       name: config.name,
       hooksInstalled: true,
       configStatus: "configured",

package/dist/job-HIDMAFW2.js

@@ -0,0 +1,376 @@
+import {
+  JOBS_DIR,
+  jobFile
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/job.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function generateJobId() {
+  const ts = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `job-${ts}-${rand}`;
+}
+function loadJob(jobId) {
+  const filePath = jobFile(jobId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveJob(job) {
+  fs.mkdirSync(JOBS_DIR, { recursive: true });
+  fs.writeFileSync(jobFile(job.id), JSON.stringify(job, null, 2), "utf-8");
+}
+function listAllJobs() {
+  if (!fs.existsSync(JOBS_DIR)) return [];
+  const files = fs.readdirSync(JOBS_DIR).filter((f) => f.endsWith(".json"));
+  const jobs = [];
+  for (const file of files) {
+    try {
+      const raw = fs.readFileSync(path.join(JOBS_DIR, file), "utf-8");
+      jobs.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  jobs.sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+  return jobs;
+}
+async function runJobCommand(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "create":
+      return await createSubcommand(args.slice(1), projectDir);
+    case "list":
+      return listSubcommand();
+    case "status":
+      return statusSubcommand(args.slice(1));
+    case "cancel":
+      return cancelSubcommand(args.slice(1));
+    case "logs":
+      return logsSubcommand(args.slice(1));
+    default:
+      printHelp();
+  }
+}
+function printHelp() {
+  console.log(`
+Usage: ulpi job <subcommand> [options]
+
+Subcommands:
+  create [options]      Create and start a new job
+  list                  List all jobs
+  status <job-id>       Show status of a specific job
+  cancel <job-id>       Cancel a running job
+  logs <job-id>         Show job logs
+
+Create options:
+  --tasks <file>        Task file (JSON)
+  --branch <name>       Source branch
+  --agent <name>        Agent override (default: claude)
+  --tracker <name>      Tracker plugin (default: json)
+  --auto-commit         Auto-commit after task completion
+  --jira-sprint <id>    Import from Jira sprint (Phase 2)
+`.trim());
+}
+async function createSubcommand(args, projectDir) {
+  const tasksFile = getFlag(args, "--tasks");
+  const branch = getFlag(args, "--branch");
+  const agentName = getFlag(args, "--agent") ?? "claude";
+  const trackerName = getFlag(args, "--tracker") ?? "json";
+  const autoCommit = hasFlag(args, "--auto-commit");
+  const jiraSprint = getFlag(args, "--jira-sprint");
+  if (jiraSprint) {
+    console.log(
+      chalk.yellow("Jira sprint import is not yet available (Phase 2).")
+    );
+    return;
+  }
+  if (trackerName === "json") {
+    const resolvedTasks = tasksFile ? path.resolve(tasksFile) : path.join(projectDir, "tasks.json");
+    if (!fs.existsSync(resolvedTasks)) {
+      console.error(
+        chalk.red(
+          `Tasks file not found: ${resolvedTasks}
+Create a tasks.json or specify one with --tasks <file>`
+        )
+      );
+      process.exit(1);
+    }
+  }
+  if (branch) {
+    try {
+      const { execFileSync } = await import("child_process");
+      execFileSync("git", ["rev-parse", "--verify", branch], {
+        cwd: projectDir,
+        encoding: "utf-8",
+        timeout: 5e3
+      });
+    } catch {
+      console.error(chalk.red(`Branch '${branch}' does not exist.`));
+      process.exit(1);
+    }
+  }
+  const jobId = generateJobId();
+  const job = {
+    id: jobId,
+    status: "pending",
+    agentName,
+    trackerName,
+    workingDir: projectDir,
+    tasksFile: tasksFile ? path.resolve(tasksFile) : void 0,
+    sourceBranch: branch,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedTasks: 0,
+    failedTasks: 0,
+    skippedTasks: 0,
+    totalTasks: 0
+  };
+  saveJob(job);
+  console.log(chalk.green(`Job created: ${chalk.bold(jobId)}`));
+  console.log(chalk.dim(`  Agent:   ${agentName}`));
+  console.log(chalk.dim(`  Tracker: ${trackerName}`));
+  console.log(chalk.dim(`  Dir:     ${projectDir}`));
+  if (branch) {
+    console.log(chalk.dim(`  Branch:  ${branch}`));
+  }
+  if (autoCommit) {
+    console.log(chalk.dim(`  Auto-commit: enabled`));
+  }
+  console.log();
+  const { ExecutionEngine } = await import("./dist-2BJYR5EI.js");
+  const trackerConfig = {};
+  if (trackerName === "json") {
+    trackerConfig.path = tasksFile ? path.resolve(tasksFile) : path.join(projectDir, "tasks.json");
+  }
+  const engineConfig = {
+    agentName,
+    trackerName,
+    trackerConfig,
+    workingDir: projectDir,
+    sourceBranch: branch,
+    maxRetries: 3,
+    retryDelayMs: 5e3,
+    autoCommit,
+    timeout: 0,
+    maxIterations: 0,
+    iterationDelayMs: 0,
+    errorStrategy: "retry",
+    rateLimit: {
+      enabled: true,
+      maxRetries: 3,
+      baseBackoffMs: 5e3,
+      recoverPrimaryBetweenIterations: true
+    },
+    agentConfig: {}
+  };
+  const engine = new ExecutionEngine(engineConfig);
+  job.status = "running";
+  job.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveJob(job);
+  let stopping = false;
+  const sigHandler = async () => {
+    if (stopping) {
+      process.exit(1);
+    }
+    stopping = true;
+    console.log(chalk.yellow("\nInterrupted. Stopping job..."));
+    await engine.stop();
+    job.status = "cancelled";
+    job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const state = engine.getState();
+    job.completedTasks = state.completedTasks.length;
+    job.failedTasks = state.failedTasks.length;
+    job.skippedTasks = state.skippedTasks.length;
+    saveJob(job);
+  };
+  process.on("SIGINT", sigHandler);
+  engine.on((event) => {
+    if (event.type === "task:completed") {
+      job.completedTasks++;
+      saveJob(job);
+    } else if (event.type === "task:failed") {
+      job.failedTasks++;
+      saveJob(job);
+    } else if (event.type === "task:skipped") {
+      job.skippedTasks++;
+      saveJob(job);
+    } else if (event.type === "engine:started") {
+      job.totalTasks = event.totalTasks;
+      saveJob(job);
+    }
+  });
+  try {
+    await engine.initialize();
+    await engine.start();
+    job.status = "completed";
+    job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const state = engine.getState();
+    job.completedTasks = state.completedTasks.length;
+    job.failedTasks = state.failedTasks.length;
+    job.skippedTasks = state.skippedTasks.length;
+    saveJob(job);
+    console.log(chalk.green(`
+Job ${jobId} completed.`));
+  } catch (err) {
+    job.status = "failed";
+    job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    job.error = err instanceof Error ? err.message : String(err);
+    saveJob(job);
+    console.error(
+      chalk.red(
+        `
+Job ${jobId} failed: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  } finally {
+    process.removeListener("SIGINT", sigHandler);
+  }
+}
+function listSubcommand() {
+  const jobs = listAllJobs();
+  if (jobs.length === 0) {
+    console.log(chalk.dim("No jobs found."));
+    return;
+  }
+  console.log(chalk.bold("Jobs"));
+  console.log(chalk.dim("\u2500".repeat(80)));
+  for (const job of jobs) {
+    const statusColor = job.status === "completed" ? chalk.green : job.status === "running" ? chalk.blue : job.status === "failed" ? chalk.red : job.status === "cancelled" ? chalk.yellow : chalk.dim;
+    const age = formatAge(job.createdAt);
+    console.log(
+      `  ${chalk.bold(job.id)}  ${statusColor(job.status.padEnd(10))}  ${chalk.cyan(job.agentName)}  ${job.completedTasks}/${job.totalTasks} tasks  ${chalk.dim(age)}`
+    );
+  }
+  console.log(chalk.dim("\u2500".repeat(80)));
+}
+function statusSubcommand(args) {
+  const jobId = args[0];
+  if (!jobId) {
+    console.error(chalk.red("Usage: ulpi job status <job-id>"));
+    process.exit(1);
+  }
+  const job = loadJob(jobId);
+  if (!job) {
+    console.error(chalk.red(`Job not found: ${jobId}`));
+    process.exit(1);
+  }
+  console.log(chalk.bold(`Job: ${job.id}`));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(`  Status:    ${formatStatus(job.status)}`);
+  console.log(`  Agent:     ${chalk.cyan(job.agentName)}`);
+  console.log(`  Tracker:   ${chalk.cyan(job.trackerName)}`);
+  console.log(`  Directory: ${chalk.dim(job.workingDir)}`);
+  if (job.sourceBranch) {
+    console.log(`  Branch:    ${job.sourceBranch}`);
+  }
+  console.log(`  Created:   ${job.createdAt}`);
+  if (job.startedAt) {
+    console.log(`  Started:   ${job.startedAt}`);
+  }
+  if (job.completedAt) {
+    console.log(`  Finished:  ${job.completedAt}`);
+  }
+  console.log();
+  console.log(`  Tasks: ${job.completedTasks}/${job.totalTasks} completed`);
+  if (job.failedTasks > 0) {
+    console.log(`  Failed:  ${chalk.red(String(job.failedTasks))}`);
+  }
+  if (job.skippedTasks > 0) {
+    console.log(`  Skipped: ${chalk.yellow(String(job.skippedTasks))}`);
+  }
+  if (job.error) {
+    console.log(`  Error:   ${chalk.red(job.error)}`);
+  }
+  console.log(chalk.dim("\u2500".repeat(40)));
+}
+function cancelSubcommand(args) {
+  const jobId = args[0];
+  if (!jobId) {
+    console.error(chalk.red("Usage: ulpi job cancel <job-id>"));
+    process.exit(1);
+  }
+  const job = loadJob(jobId);
+  if (!job) {
+    console.error(chalk.red(`Job not found: ${jobId}`));
+    process.exit(1);
+  }
+  if (job.status !== "running" && job.status !== "pending") {
+    console.log(
+      chalk.yellow(`Job ${jobId} is not running (status: ${job.status})`)
+    );
+    return;
+  }
+  job.status = "cancelled";
+  job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  saveJob(job);
+  console.log(chalk.yellow(`Job ${jobId} cancelled.`));
+}
+function logsSubcommand(args) {
+  const jobId = args[0];
+  if (!jobId) {
+    console.error(chalk.red("Usage: ulpi job logs <job-id>"));
+    process.exit(1);
+  }
+  const job = loadJob(jobId);
+  if (!job) {
+    console.error(chalk.red(`Job not found: ${jobId}`));
+    process.exit(1);
+  }
+  console.log(chalk.bold(`Logs for job: ${job.id}`));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(chalk.dim("Job log streaming is not yet implemented."));
+  console.log(chalk.dim(`Job status: ${job.status}`));
+  console.log(chalk.dim(`Tasks: ${job.completedTasks}/${job.totalTasks}`));
+  if (job.error) {
+    console.log(chalk.red(`Error: ${job.error}`));
+  }
+  console.log(chalk.dim("\u2500".repeat(40)));
+}
+function formatStatus(status) {
+  switch (status) {
+    case "completed":
+      return chalk.green(status);
+    case "running":
+      return chalk.blue(status);
+    case "failed":
+      return chalk.red(status);
+    case "cancelled":
+      return chalk.yellow(status);
+    case "pending":
+      return chalk.dim(status);
+    default:
+      return status;
+  }
+}
+function formatAge(isoDate) {
+  const ms = Date.now() - new Date(isoDate).getTime();
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+export {
+  runJobCommand
+};

package/dist/jobs.memory-PLMMSFHB-VBECCTHN.js

@@ -0,0 +1,33 @@
+import {
+  readEventLogs
+} from "./chunk-4XTHZVDS.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// ../api/dist/jobs.memory-PLMMSFHB.js
+async function captureAndClassifyJob(projectDir, jobId, mode, agentName, job) {
+  const { captureJobForClassification, isMemoryEnabled } = await import("./dist-JLU26AB6.js");
+  if (!isMemoryEnabled(projectDir)) return;
+  const events = readEventLogs(jobId);
+  if (events.length === 0) return;
+  captureJobForClassification(projectDir, jobId, events, {
+    jobId,
+    mode,
+    agentName,
+    startedAt: job.startedAt ?? job.createdAt,
+    endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tasksCompleted: job.completedTasks?.length ?? 0,
+    tasksFailed: job.failedTasks?.length ?? 0,
+    totalIterations: events.filter((e) => e.type === "iteration:started").length
+  });
+  const { spawn } = await import("child_process");
+  const child = spawn(
+    process.execPath,
+    [process.argv[1], "memory", "classify", "-p", projectDir, "--session", jobId],
+    { detached: true, stdio: "ignore", env: { ...process.env, ULPI_BG_CLASSIFY: "1" } }
+  );
+  child.unref();
+}
+export {
+  captureAndClassifyJob
+};