@ulpi/cli 0.1.0

package/dist/init-AY5C2ZAS.js

@@ -0,0 +1,393 @@
+import {
+  installGlobalSkill,
+  installHooks,
+  installLocalSkill
+} from "./chunk-QJ5GSMEC.js";
+import {
+  detectStack
+} from "./chunk-2CLNOKPA.js";
+import {
+  registerProject
+} from "./chunk-SPOI23SB.js";
+import {
+  composeTemplates,
+  loadBundledTemplates,
+  resolveTemplate
+} from "./chunk-6OCEY7JY.js";
+import {
+  DEFAULT_AI_MODEL,
+  GUARDS_FILENAME,
+  getApiPort,
+  projectConfigDir
+} from "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/init.ts
+import * as fs from "fs";
+import * as path from "path";
+import { execFileSync, spawn } from "child_process";
+import chalk from "chalk";
+
+// src/ai-scan/response-parser.ts
+function parseAIScanResponse(response) {
+  const yamlMatch = response.match(/```ya?ml\n([\s\S]*?)```/);
+  if (yamlMatch) {
+    return yamlMatch[1].trim();
+  }
+  const codeMatch = response.match(/```\n([\s\S]*?)```/);
+  if (codeMatch) {
+    return codeMatch[1].trim();
+  }
+  if (response.trim().match(/^[a-z_]+:/m)) {
+    return response.trim();
+  }
+  return null;
+}
+function validateScanResult(yaml) {
+  const warnings = [];
+  const sections = ["preconditions", "postconditions", "permissions", "pipelines"];
+  let foundSections = 0;
+  for (const section of sections) {
+    if (yaml.includes(`${section}:`)) {
+      foundSections++;
+    } else {
+      warnings.push(`Missing section: ${section}`);
+    }
+  }
+  return {
+    valid: foundSections > 0,
+    warnings
+  };
+}
+
+// src/commands/init.ts
+async function runInit(args) {
+  const projectDir = path.resolve(args[0] ?? process.cwd());
+  const noAi = args.includes("--no-ai");
+  const modelFlag = args.find((a) => a.startsWith("--model="));
+  const model = modelFlag ? modelFlag.split("=")[1] : DEFAULT_AI_MODEL;
+  if (!fs.existsSync(projectDir) || !fs.statSync(projectDir).isDirectory()) {
+    console.log(chalk.red(`Error: Project directory does not exist or is not a directory: ${projectDir}`));
+    return;
+  }
+  if (projectDir.includes("..")) {
+    console.log(chalk.red("Error: Invalid project directory path."));
+    return;
+  }
+  console.log(chalk.bold("\nULPI \u2014 Project Setup\n"));
+  const rulesDir = projectConfigDir(projectDir);
+  const rulesPath = path.join(rulesDir, GUARDS_FILENAME);
+  fs.mkdirSync(rulesDir, { recursive: true });
+  console.log(chalk.cyan("Detecting project stack..."));
+  const stack = detectStack(projectDir);
+  printDetectedStack(stack);
+  console.log(chalk.cyan("\nInstalling Claude Code hooks..."));
+  installHooks(projectDir);
+  console.log(chalk.green("\u2713 Hooks installed in .claude/settings.local.json"));
+  const localResult = installLocalSkill(projectDir);
+  if (localResult.installed) {
+    console.log(chalk.green(`\u2713 ${localResult.message}`));
+  }
+  const globalResult = installGlobalSkill();
+  if (globalResult.installed) {
+    console.log(chalk.green(`\u2713 ${globalResult.message}`));
+  } else if (!globalResult.message.includes("already installed") && !globalResult.message.includes("not found")) {
+    console.log(chalk.yellow(`\u26A0 ${globalResult.message}`));
+  }
+  try {
+    const { isSupported, isLaunchAgentInstalled, needsLegacyMigration, installLaunchAgent } = await import("./launchd-LF2QMSKZ.js");
+    if (isSupported() && (!isLaunchAgentInstalled() || needsLegacyMigration())) {
+      const migrating = needsLegacyMigration();
+      installLaunchAgent();
+      if (migrating) {
+        console.log(chalk.green("\u2713 Migrated LaunchAgent from com.ulpi.guardian.ui \u2192 com.ulpi.ui"));
+      } else {
+        console.log(chalk.green("\u2713 Installed LaunchAgent for UI server (auto-starts on login)"));
+      }
+      console.log(chalk.dim(`  Web UI: http://localhost:${getApiPort()}`));
+    }
+  } catch {
+  }
+  try {
+    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-NQCGKQ23.js");
+    const codemapMcp = installMcpServer(projectDir);
+    if (codemapMcp.installed) {
+      console.log(chalk.green("\u2713 CodeMap MCP server registered"));
+    }
+    const memoryMcp = installMemoryMcpServer(projectDir);
+    if (memoryMcp.installed) {
+      console.log(chalk.green("\u2713 Memory MCP server registered"));
+    }
+  } catch {
+  }
+  try {
+    const { runInitPipeline } = await import("./dist-LZKZFPVX.js");
+    const { initMemoryBranch } = await import("./dist-R5F4MX3I.js");
+    console.log(chalk.cyan("\nInitializing code index..."));
+    try {
+      await runInitPipeline(projectDir, (progress) => {
+        if (progress.message) {
+          process.stdout.write(`\r  ${chalk.dim(progress.message)}${"".padEnd(20)}`);
+        }
+      });
+      process.stdout.write("\r");
+      console.log(chalk.green("\u2713 Code index initialized"));
+    } catch {
+      console.log(chalk.dim("  Skipped code indexing (embedding API unavailable)"));
+    }
+    try {
+      initMemoryBranch(projectDir);
+      console.log(chalk.green("\u2713 Memory branch initialized"));
+    } catch {
+      console.log(chalk.dim("  Skipped memory init"));
+    }
+  } catch {
+  }
+  const config = buildStackConfig(stack, projectDir);
+  let generated = false;
+  if (!noAi) {
+    generated = await attemptAiGeneration(projectDir, rulesPath, model);
+  }
+  if (!generated) {
+    if (!noAi) {
+      console.log(chalk.yellow("\nFalling back to template-based generation..."));
+    }
+    generateFromTemplates(projectDir, rulesPath, stack, config);
+  }
+  try {
+    registerProject(projectDir, {
+      name: config.name,
+      hooksInstalled: true,
+      configStatus: "configured",
+      stack: {
+        runtime: stack.runtime?.name,
+        framework: stack.framework?.name,
+        packageManager: stack.packageManager?.name
+      }
+    });
+    console.log(chalk.green("\u2713 Project registered in global registry"));
+  } catch {
+  }
+  console.log(chalk.bold.green("\nSetup complete! ULPI is now active.\n"));
+}
+function isClaudeCliAvailable() {
+  try {
+    execFileSync("claude", ["--version"], { stdio: "pipe", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runClaudeCli(projectDir, model) {
+  return new Promise((resolve2, reject) => {
+    const timeout = 3 * 60 * 1e3;
+    const proc = spawn("claude", [
+      "--print",
+      "--model",
+      model,
+      "--output-format",
+      "text",
+      "--permission-mode",
+      "bypassPermissions",
+      `/ulpi-generate-guardian ${projectDir}`
+    ], {
+      cwd: projectDir,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const timer = setTimeout(() => {
+      proc.kill("SIGTERM");
+      reject(new Error("AI generation timed out after 3 minutes"));
+    }, timeout);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`claude CLI exited with code ${code}: ${stderr.slice(0, 500)}`));
+      } else {
+        resolve2({ stdout, stderr });
+      }
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Failed to run claude CLI: ${err.message}`));
+    });
+  });
+}
+async function attemptAiGeneration(projectDir, rulesPath, model) {
+  if (!isClaudeCliAvailable()) {
+    console.log(chalk.dim("Claude CLI not found, skipping AI generation."));
+    return false;
+  }
+  console.log(chalk.cyan(`
+Generating guards with AI (${model})...`));
+  console.log(chalk.dim("This may take a few minutes."));
+  try {
+    const { stdout } = await runClaudeCli(projectDir, model);
+    const yaml = parseAIScanResponse(stdout);
+    if (!yaml) {
+      console.log(chalk.yellow("\u26A0 Could not parse AI response as YAML."));
+      return false;
+    }
+    const validation = validateScanResult(yaml);
+    if (!validation.valid) {
+      console.log(chalk.yellow(`\u26A0 AI response missing required sections: ${validation.warnings.join(", ")}`));
+      return false;
+    }
+    const header = [
+      "# ULPI \u2014 AI-Generated Rules",
+      `# Generated by AI on ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      `# Model: ${model}`,
+      "# Review these rules and adjust as needed.",
+      ""
+    ].join("\n");
+    fs.writeFileSync(rulesPath, header + yaml + "\n", "utf-8");
+    console.log(chalk.green(`\u2713 AI-generated guards.yml`));
+    if (validation.warnings.length > 0) {
+      for (const w of validation.warnings) {
+        console.log(chalk.yellow(`  \u26A0 ${w}`));
+      }
+    }
+    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.yellow(`\u26A0 AI generation failed: ${message}`));
+    return false;
+  }
+}
+function generateFromTemplates(projectDir, rulesPath, stack, config) {
+  console.log(chalk.cyan("\nSelecting templates..."));
+  const templates = selectTemplates(stack);
+  if (templates.length === 0) {
+    console.log(chalk.yellow("No matching templates found. Using quality-of-life defaults."));
+  } else {
+    console.log(`Selected ${templates.length} template(s):`);
+    for (const t of templates) {
+      console.log(`  ${chalk.green("\u2713")} ${t.name} (${t.category})`);
+    }
+  }
+  const composed = composeTemplates(templates);
+  const resolved = resolveTemplate(composed, config);
+  const rulesYaml = generateRulesYaml(resolved, config);
+  fs.writeFileSync(rulesPath, rulesYaml, "utf-8");
+  console.log(chalk.green(`\u2713 Generated ${rulesPath}`));
+}
+function printDetectedStack(stack) {
+  const items = [
+    ["Runtime", stack.runtime],
+    ["Language", stack.language],
+    ["Framework", stack.framework],
+    ["Package Manager", stack.packageManager],
+    ["Formatter", stack.formatter],
+    ["Linter", stack.linter],
+    ["Test Runner", stack.testRunner],
+    ["ORM", stack.orm],
+    ["Git Workflow", stack.gitWorkflow]
+  ];
+  for (const [label, item] of items) {
+    if (item) {
+      console.log(`  ${chalk.green("\u2713")} ${label}: ${chalk.bold(item.name)} (${item.confidence})`);
+    }
+  }
+  if (stack.features.length > 0) {
+    console.log(`  Features: ${stack.features.join(", ")}`);
+  }
+}
+function selectTemplates(stack) {
+  const all = loadBundledTemplates();
+  const selected = [];
+  const qol = all.find((t) => t.id === "quality-of-life");
+  if (qol) selected.push(qol);
+  const detectors = [
+    stack.runtime,
+    stack.language,
+    stack.packageManager,
+    stack.framework,
+    stack.formatter,
+    stack.linter,
+    stack.testRunner,
+    stack.orm,
+    stack.gitWorkflow
+  ];
+  for (const det of detectors) {
+    if (det) {
+      const t = all.find((l) => l.id === det.id);
+      if (t && !selected.includes(t)) selected.push(t);
+    }
+  }
+  return selected;
+}
+function buildStackConfig(stack, projectDir) {
+  return {
+    name: path.basename(projectDir),
+    runtime: stack.runtime?.id ?? "unknown",
+    language: stack.language?.id,
+    framework: stack.framework?.id,
+    package_manager: stack.packageManager?.id ?? "npm",
+    orm: stack.orm?.id,
+    test_runner: stack.testRunner?.id,
+    formatter: stack.formatter?.id,
+    linter: stack.linter?.id,
+    git_workflow: stack.gitWorkflow?.id
+  };
+}
+function generateRulesYaml(resolved, config) {
+  const lines = [
+    "# ULPI \u2014 Rules Configuration",
+    "# Generated automatically based on detected stack.",
+    `# Project: ${config.name}`,
+    `# Package Manager: ${config.package_manager}`,
+    "",
+    "project:",
+    `  name: "${config.name}"`,
+    `  runtime: "${config.runtime}"`,
+    `  package_manager: "${config.package_manager}"`,
+    ""
+  ];
+  const sections = ["preconditions", "postconditions", "permissions", "pipelines"];
+  for (const section of sections) {
+    const data = resolved[section];
+    if (data && Object.keys(data).length > 0) {
+      lines.push(`${section}:`);
+      for (const [key, rule] of Object.entries(data)) {
+        lines.push(`  ${key}:`);
+        writeYamlObject(rule, lines, 4);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function writeYamlObject(obj, lines, indent) {
+  const pad = " ".repeat(indent);
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "id" || k === "type" || k === "source") continue;
+    if (typeof v === "string") {
+      lines.push(`${pad}${k}: "${v}"`);
+    } else if (typeof v === "boolean" || typeof v === "number") {
+      lines.push(`${pad}${k}: ${v}`);
+    } else if (Array.isArray(v)) {
+      lines.push(`${pad}${k}:`);
+      for (const item of v) {
+        if (typeof item === "string") {
+          lines.push(`${pad}  - "${item}"`);
+        } else if (typeof item === "object" && item !== null) {
+          lines.push(`${pad}  -`);
+          writeYamlObject(item, lines, indent + 4);
+        }
+      }
+    } else if (v !== null && typeof v === "object") {
+      lines.push(`${pad}${k}:`);
+      writeYamlObject(v, lines, indent + 2);
+    }
+  }
+}
+export {
+  runInit
+};

package/dist/launchd-LF2QMSKZ.js

@@ -0,0 +1,148 @@
+import "./chunk-QJ5GSMEC.js";
+import {
+  LAUNCHD_LABEL,
+  LOGS_DIR,
+  getApiPort,
+  getBinaryPath
+} from "./chunk-7LXY5UVC.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/launchd.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execFileSync } from "child_process";
+var PLIST_LABEL = LAUNCHD_LABEL;
+var PLIST_DIR = path.join(os.homedir(), "Library", "LaunchAgents");
+var PLIST_PATH = path.join(PLIST_DIR, `${PLIST_LABEL}.plist`);
+var LOG_DIR = LOGS_DIR;
+var LEGACY_PLIST_LABEL = "com.ulpi.guardian.ui";
+var LEGACY_PLIST_PATH = path.join(PLIST_DIR, `${LEGACY_PLIST_LABEL}.plist`);
+function isSupported() {
+  return process.platform === "darwin";
+}
+function isLaunchAgentInstalled() {
+  return fs.existsSync(PLIST_PATH);
+}
+function needsLegacyMigration() {
+  return fs.existsSync(LEGACY_PLIST_PATH);
+}
+function generatePlist(options = {}) {
+  const port = options.port ?? getApiPort();
+  const binary = getBinaryPath();
+  const firstSpace = binary.indexOf(" ");
+  const parts = firstSpace === -1 ? [binary] : [binary.slice(0, firstSpace), binary.slice(firstSpace + 1)];
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i].replace(/^"|"$/g, "");
+    if (p && !p.startsWith("/")) {
+      try {
+        const resolved = execFileSync("which", [p], { encoding: "utf-8", timeout: 3e3 }).trim();
+        if (resolved) parts[i] = resolved;
+        else parts[i] = p;
+      } catch {
+        parts[i] = p;
+      }
+    } else {
+      parts[i] = p;
+    }
+  }
+  const programArgs = parts.map((p) => `      <string>${escapeXml(p)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs}
+      <string>ui</string>
+      <string>--port</string>
+      <string>${port}</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+      <key>ULPI_API_PORT</key>
+      <string>${port}</string>
+    </dict>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${escapeXml(path.join(LOG_DIR, "ulpi.stdout.log"))}</string>
+    <key>StandardErrorPath</key>
+    <string>${escapeXml(path.join(LOG_DIR, "ulpi.stderr.log"))}</string>
+</dict>
+</plist>
+`;
+}
+function cleanupLegacyAgent() {
+  try {
+    if (fs.existsSync(LEGACY_PLIST_PATH)) {
+      try {
+        execFileSync("launchctl", ["unload", LEGACY_PLIST_PATH], { stdio: "pipe" });
+      } catch {
+      }
+      fs.unlinkSync(LEGACY_PLIST_PATH);
+    }
+  } catch {
+  }
+}
+function installLaunchAgent(options = {}) {
+  if (!isSupported()) return;
+  try {
+    cleanupLegacyAgent();
+    fs.mkdirSync(PLIST_DIR, { recursive: true });
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+    const plist = generatePlist(options);
+    fs.writeFileSync(PLIST_PATH, plist, "utf-8");
+    try {
+      execFileSync("launchctl", ["load", "-w", PLIST_PATH], { stdio: "pipe" });
+    } catch {
+      try {
+        execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+        execFileSync("launchctl", ["load", "-w", PLIST_PATH], { stdio: "pipe" });
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function uninstallLaunchAgent() {
+  if (!isSupported()) return;
+  cleanupLegacyAgent();
+  try {
+    if (fs.existsSync(PLIST_PATH)) {
+      try {
+        execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+      } catch {
+      }
+      fs.unlinkSync(PLIST_PATH);
+    }
+  } catch {
+  }
+}
+function restartLaunchAgent() {
+  if (!isSupported() || !fs.existsSync(PLIST_PATH)) return;
+  try {
+    execFileSync("launchctl", ["unload", PLIST_PATH], { stdio: "pipe" });
+  } catch {
+  }
+  try {
+    execFileSync("launchctl", ["load", "-w", PLIST_PATH], { stdio: "pipe" });
+  } catch {
+  }
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+export {
+  generatePlist,
+  installLaunchAgent,
+  isLaunchAgentInstalled,
+  isSupported,
+  needsLegacyMigration,
+  restartLaunchAgent,
+  uninstallLaunchAgent
+};

package/dist/log-TVTUXAYD.js

@@ -0,0 +1,75 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/log.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import chalk from "chalk";
+async function runLog(args, _projectDir) {
+  const count = parseInt(args[0] ?? "20", 10);
+  const logsDir = path.join(os.homedir(), ".ulpi", "events");
+  if (!fs.existsSync(logsDir)) {
+    console.log(chalk.yellow("No activity logs found."));
+    return;
+  }
+  const files = fs.readdirSync(logsDir).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+  if (files.length === 0) {
+    console.log(chalk.yellow("No activity logs found."));
+    return;
+  }
+  console.log(chalk.bold("\nRecent Activity\n"));
+  let shown = 0;
+  for (const file of files) {
+    if (shown >= count) break;
+    const content = fs.readFileSync(path.join(logsDir, file), "utf-8");
+    const lines = content.trim().split("\n").reverse();
+    for (const line of lines) {
+      if (shown >= count) break;
+      try {
+        const event = JSON.parse(line);
+        printEvent(event);
+        shown++;
+      } catch {
+      }
+    }
+  }
+  console.log("");
+}
+function printEvent(event) {
+  const time = chalk.dim(event.ts.slice(11, 19));
+  const eventType = colorEvent(event.event);
+  const details = [];
+  if (event.toolName) details.push(chalk.cyan(event.toolName));
+  if (event.filePath) details.push(event.filePath);
+  if (event.command) details.push(chalk.dim(truncate(event.command, 50)));
+  if (event.ruleName) details.push(chalk.yellow(event.ruleName));
+  if (event.message) details.push(event.message);
+  console.log(`  ${time}  ${eventType}  ${details.join(" \u2014 ")}`);
+}
+function colorEvent(event) {
+  switch (event) {
+    case "tool_blocked":
+    case "postcondition_failed":
+    case "pipeline_failed":
+    case "permission_deny":
+      return chalk.red(padRight(event, 22));
+    case "tool_allowed":
+    case "permission_allow":
+    case "pipeline_complete":
+      return chalk.green(padRight(event, 22));
+    case "session_start":
+    case "session_end":
+      return chalk.blue(padRight(event, 22));
+    default:
+      return chalk.white(padRight(event, 22));
+  }
+}
+function padRight(str, len) {
+  return str.length >= len ? str : str + " ".repeat(len - str.length);
+}
+function truncate(str, maxLen) {
+  return str.length > maxLen ? str.slice(0, maxLen - 1) + "\u2026" : str;
+}
+export {
+  runLog
+};