@ulpi/cli 0.1.5 → 0.1.6

package/dist/doctor-SI4LLLDZ.js

@@ -0,0 +1,345 @@
+import {
+  API_LOCK_FILE,
+  ULPI_GLOBAL_DIR,
+  loadUlpiSettings,
+  projectGuardsFile
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/doctor.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execFileSync } from "child_process";
+import chalk from "chalk";
+var PASS = chalk.green("\u2713");
+var FAIL = chalk.red("\u2717");
+var WARN = chalk.yellow("\u26A0");
+var AGENTS = [
+  {
+    name: "Claude Code",
+    cliCommand: "claude",
+    tier: 1,
+    hookConfigPath: (dir) => path.join(dir, ".claude", "settings.local.json"),
+    mcpConfigPath: () => path.join(os.homedir(), ".claude", "settings.json")
+  },
+  {
+    name: "Gemini CLI",
+    cliCommand: "gemini",
+    tier: 1,
+    hookConfigPath: (dir) => path.join(dir, ".gemini", "settings.json"),
+    mcpConfigPath: () => {
+      const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+      return path.join(xdg, "gemini", "settings.json");
+    }
+  },
+  {
+    name: "OpenCode",
+    cliCommand: "opencode",
+    tier: 1,
+    hookConfigPath: (dir) => path.join(dir, ".opencode", "config.json"),
+    mcpConfigPath: () => {
+      const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+      return path.join(xdg, "opencode", "config.json");
+    }
+  },
+  {
+    name: "Codex",
+    cliCommand: "codex",
+    tier: 2,
+    hookConfigPath: () => null,
+    mcpConfigPath: () => path.join(os.homedir(), ".codex", "config.json")
+  },
+  {
+    name: "Kiro CLI",
+    cliCommand: "kiro",
+    tier: 2,
+    hookConfigPath: () => null,
+    mcpConfigPath: () => path.join(os.homedir(), ".kiro", "settings", "mcp.json")
+  },
+  {
+    name: "Factory Droid",
+    cliCommand: "droid",
+    tier: 3,
+    hookConfigPath: () => null,
+    mcpConfigPath: () => {
+      const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+      return path.join(xdg, "droid", "mcp.json");
+    }
+  }
+];
+var passCount = 0;
+var failCount = 0;
+var warnCount = 0;
+function pass(message) {
+  console.log(`  ${PASS} ${message}`);
+  passCount++;
+}
+function fail(message) {
+  console.log(`  ${FAIL} ${message}`);
+  failCount++;
+}
+function warn(message) {
+  console.log(`  ${WARN} ${message}`);
+  warnCount++;
+}
+function section(title) {
+  console.log(`
+  ${chalk.bold(title)}`);
+}
+function isCommandAvailable(command) {
+  try {
+    execFileSync("which", [command], { encoding: "utf-8", timeout: 5e3 });
+    try {
+      const version = execFileSync(command, ["--version"], {
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const match = version.match(/v?(\d+\.\d+\.\d+[^\s]*)/);
+      return { available: true, version: match?.[1] ?? version.split("\n")[0] };
+    } catch {
+      return { available: true };
+    }
+  } catch {
+    return { available: false };
+  }
+}
+function isApiServerRunning() {
+  try {
+    if (!fs.existsSync(API_LOCK_FILE)) return false;
+    const content = fs.readFileSync(API_LOCK_FILE, "utf-8");
+    const lock = JSON.parse(content);
+    if (lock.pid) {
+      try {
+        process.kill(lock.pid, 0);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function guardsYmlValid(projectDir) {
+  const guardsPath = projectGuardsFile(projectDir);
+  if (!fs.existsSync(guardsPath)) {
+    return { valid: false, error: "not found" };
+  }
+  try {
+    const content = fs.readFileSync(guardsPath, "utf-8");
+    if (!content.trim()) {
+      return { valid: false, error: "empty file" };
+    }
+    if (content.includes("project:") || content.includes("preconditions:") || content.includes("permissions:") || content.includes("postconditions:") || content.includes("pipelines:")) {
+      return { valid: true };
+    }
+    return { valid: false, error: "missing expected sections" };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { valid: false, error: msg };
+  }
+}
+function checkMcpConfigured(configPath, serverName) {
+  try {
+    if (!fs.existsSync(configPath)) return false;
+    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return !!config.mcpServers?.[serverName];
+  } catch {
+    return false;
+  }
+}
+function checkHooksInstalled(configPath) {
+  if (!configPath) return false;
+  try {
+    if (!fs.existsSync(configPath)) return false;
+    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return !!config.hooks && Object.keys(config.hooks).length > 0;
+  } catch {
+    return false;
+  }
+}
+function checkCore(projectDir) {
+  section("Core");
+  try {
+    const version = "0.1.6";
+    pass(`ULPI CLI version: ${version}`);
+  } catch {
+    pass("ULPI CLI: installed");
+  }
+  const nodeVersion = process.version;
+  const major = parseInt(nodeVersion.slice(1), 10);
+  if (major >= 20) {
+    pass(`Node.js version: ${nodeVersion}`);
+  } else {
+    fail(`Node.js version: ${nodeVersion} (requires >= 20)`);
+  }
+  if (fs.existsSync(path.join(projectDir, ".ulpi"))) {
+    pass(`Project directory: ${projectDir}`);
+  } else {
+    warn(`Project directory: ${projectDir} (no .ulpi/ folder)`);
+  }
+  const guards = guardsYmlValid(projectDir);
+  if (guards.valid) {
+    pass(`Guards config: ${path.relative(projectDir, projectGuardsFile(projectDir))} (valid)`);
+  } else if (guards.error === "not found") {
+    fail("Guards config: not found (run: ulpi init)");
+  } else {
+    fail(`Guards config: invalid (${guards.error})`);
+  }
+  if (isApiServerRunning()) {
+    pass("API server: running");
+  } else {
+    fail("API server: not running (start with: ulpi ui)");
+  }
+}
+function checkAgentPlugins() {
+  section("Agent Plugins");
+  for (const agent of AGENTS) {
+    const detection = isCommandAvailable(agent.cliCommand);
+    if (detection.available) {
+      const versionStr = detection.version ? ` (${detection.version})` : "";
+      pass(`${agent.name}: installed${versionStr}`);
+    } else {
+      fail(`${agent.name}: not installed`);
+    }
+  }
+}
+function checkMcpServers() {
+  section("MCP Servers");
+  const mcpServers = ["ulpi-codemap", "ulpi-memory"];
+  let checked = false;
+  for (const agent of AGENTS) {
+    const detection = isCommandAvailable(agent.cliCommand);
+    if (!detection.available) continue;
+    const configPath = agent.mcpConfigPath();
+    for (const serverName of mcpServers) {
+      const configured = checkMcpConfigured(configPath, serverName);
+      const displayName = serverName.replace("ulpi-", "");
+      if (configured) {
+        pass(`${displayName}-mcp: configured in ${agent.name}`);
+      } else {
+        fail(`${displayName}-mcp: not configured in ${agent.name}`);
+      }
+      checked = true;
+    }
+  }
+  if (!checked) {
+    warn("No agent CLIs detected to check MCP configuration");
+  }
+}
+function checkIntelligenceLayer(projectDir) {
+  section("Intelligence Layer");
+  const projectSlug = path.basename(projectDir);
+  const codemapDir = path.join(ULPI_GLOBAL_DIR, "codemap", projectSlug);
+  if (fs.existsSync(codemapDir)) {
+    const lanceDir = path.join(codemapDir, "lance");
+    const hasVectorIndex = fs.existsSync(lanceDir);
+    const statusFile = path.join(codemapDir, "status.json");
+    if (fs.existsSync(statusFile)) {
+      try {
+        const status = JSON.parse(fs.readFileSync(statusFile, "utf-8"));
+        const details = [];
+        if (status.fileCount) details.push(`${status.fileCount} files`);
+        if (status.chunkCount) details.push(`${status.chunkCount} chunks`);
+        pass(`CodeMap index: ready${details.length ? ` (${details.join(", ")})` : ""}`);
+      } catch {
+        if (hasVectorIndex) {
+          pass("CodeMap index: ready");
+        } else {
+          fail("CodeMap index: not initialized (run: ulpi codemap init)");
+        }
+      }
+    } else if (hasVectorIndex) {
+      pass("CodeMap index: ready");
+    } else {
+      fail("CodeMap index: not initialized (run: ulpi codemap init)");
+    }
+  } else {
+    fail("CodeMap index: not initialized (run: ulpi codemap init)");
+  }
+  const memoryDir = path.join(ULPI_GLOBAL_DIR, "memory", projectSlug);
+  if (fs.existsSync(memoryDir)) {
+    const entriesDir = path.join(memoryDir, "entries");
+    let count = 0;
+    if (fs.existsSync(entriesDir)) {
+      try {
+        count = fs.readdirSync(entriesDir).filter((f) => f.endsWith(".json")).length;
+      } catch {
+      }
+    }
+    pass(`Memory store: ready (${count} memories)`);
+  } else {
+    fail("Memory store: not initialized (run: ulpi memory init)");
+  }
+  const depgraphPath = path.join(codemapDir, "depgraph.json");
+  if (fs.existsSync(depgraphPath)) {
+    pass("DepGraph: ready");
+  } else {
+    fail("DepGraph: not built (run: ulpi codemap init)");
+  }
+  try {
+    const settings = loadUlpiSettings();
+    const settingsRecord = settings;
+    const provider = settingsRecord.embedProvider;
+    const apiKeys = settingsRecord.apiKeys;
+    const hasKey = !!apiKeys?.embed || !!apiKeys?.openai;
+    if (provider === "ollama" || provider === "ulpi-cloud" || hasKey) {
+      pass(`Embeddings: ${provider ?? "configured"}`);
+    } else if (provider) {
+      pass(`Embeddings: ${provider}`);
+    } else {
+      warn("Embeddings: provider not configured (run: ulpi config set embedProvider)");
+    }
+  } catch {
+    warn("Embeddings: unable to check configuration");
+  }
+}
+function checkHookInstallation(projectDir) {
+  section("Hook Installation");
+  const hookAgents = AGENTS.filter((a) => a.tier === 1);
+  let checked = false;
+  for (const agent of hookAgents) {
+    const detection = isCommandAvailable(agent.cliCommand);
+    if (!detection.available) continue;
+    const configPath = agent.hookConfigPath(projectDir);
+    checked = true;
+    if (checkHooksInstalled(configPath)) {
+      const relPath = configPath ? path.relative(projectDir, configPath) : "unknown";
+      pass(`${agent.name} hooks: installed (${relPath})`);
+    } else {
+      fail(`${agent.name} hooks: not installed (run: ulpi init)`);
+    }
+  }
+  if (!checked) {
+    warn("No Tier 1 agent CLIs detected to check hook installation");
+  }
+}
+function runDoctorCommand(args, projectDir) {
+  passCount = 0;
+  failCount = 0;
+  warnCount = 0;
+  console.log(`
+  ${chalk.bold("ULPI System Health Check")}`);
+  console.log(`  ${"========================"}`);
+  checkCore(projectDir);
+  checkAgentPlugins();
+  checkMcpServers();
+  checkIntelligenceLayer(projectDir);
+  checkHookInstallation(projectDir);
+  console.log("");
+  const parts = [];
+  if (passCount > 0) parts.push(chalk.green(`${passCount} passed`));
+  if (failCount > 0) parts.push(chalk.red(`${failCount} issues found`));
+  if (warnCount > 0) parts.push(chalk.yellow(`${warnCount} warnings`));
+  console.log(`  Summary: ${parts.join(", ")}`);
+  console.log("");
+  if (failCount > 0) {
+    process.exit(1);
+  }
+}
+export {
+  runDoctorCommand
+};

package/dist/{export-import-4A5MWLIA.js → export-import-JFQH4KSJ.js}

@@ -1,6 +1,6 @@
 import {
   parseRules
-} from "./chunk-SIAQVRKG.js";
+} from "./chunk-5MI5GIXM.js";
 import "./chunk-KIKPIH6N.js";
 import "./chunk-4VNS5WPM.js";
 

package/dist/{history-RNUWO4JZ.js → history-5NE46ZAH.js}

@@ -19,13 +19,13 @@ import {
   readTimeline,
   updateEntryEnrichment,
   writeHistoryEntry
-} from "./chunk-L3PWNHSA.js";
-import "./chunk-26LLDX2T.js";
+} from "./chunk-3WB5CXH4.js";
+import "./chunk-SEU7WWNQ.js";
 import {
   DEFAULT_AI_MODEL,
   REVIEWS_DIR,
   getHistoryBranch
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 import "./chunk-4VNS5WPM.js";
 
 // src/commands/history.ts
@@ -416,7 +416,7 @@ async function initSubcommand(projectDir) {
   }
   const projectName = path2.basename(projectDir);
   try {
-    initHistoryBranch(projectDir, projectName, "0.1.5");
+    initHistoryBranch(projectDir, projectName, "0.1.6");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.log(chalk.red(`Error: ${message}`));
@@ -424,7 +424,7 @@ async function initSubcommand(projectDir) {
   }
   if (collectReviewPlans) {
     try {
-      const { withWorktree, writeAndStage, commitInWorktree } = await import("./dist-5R4RYNQO.js");
+      const { withWorktree, writeAndStage, commitInWorktree } = await import("./dist-YCNWHSLN.js");
       const meta = readBranchMeta(projectDir);
       if (meta) {
         meta.config.collectReviewPlans = true;
@@ -447,8 +447,8 @@ async function initSubcommand(projectDir) {
   );
   if (installHooksAnswer.trim().toLowerCase() !== "n") {
     try {
-      const { installGitHooks } = await import("./dist-5R4RYNQO.js");
-      const { getBinaryPath } = await import("./dist-GWGTAHNM.js");
+      const { installGitHooks } = await import("./dist-YCNWHSLN.js");
+      const { getBinaryPath } = await import("./dist-NUXMDXZ3.js");
       const binaryPath = getBinaryPath();
       const result = installGitHooks(projectDir, binaryPath);
       if (result.installed.length > 0) {

package/dist/{hooks-installer-K2JXEBNN.js → hooks-installer-UN5JZLDQ.js}

@@ -4,10 +4,10 @@ import {
   installHooks,
   installLocalSkill,
   uninstallHooks
-} from "./chunk-5SCG7UYM.js";
+} from "./chunk-VVEDXI7E.js";
 import {
   getBinaryPath
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 import "./chunk-4VNS5WPM.js";
 export {
   findSkillSource,