@ulpi/cli 0.1.5 → 0.1.7

package/dist/{chunk-EIWYSP3A.js → chunk-UXHCHOWQ.js}

@@ -2,14 +2,15 @@ import {
   ULPI_GLOBAL_DIR,
   projectGuardsFile,
   projectGuardsFileAlt
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
-// ../../packages/projects-engine/dist/index.js
+// ../../packages/repos-engine/dist/index.js
 import * as fs from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
 var DEFAULT_BASE_DIR = ULPI_GLOBAL_DIR;
-var REGISTRY_FILE = "projects.json";
+var REGISTRY_FILE = "repos.json";
+var LEGACY_REGISTRY_FILE = "projects.json";
 function registryPath(baseDir) {
   return path.join(baseDir, REGISTRY_FILE);
 }
@@ -18,7 +19,7 @@ function atomicWrite(filePath, data) {
   fs.writeFileSync(tmpPath, data, "utf-8");
   fs.renameSync(tmpPath, filePath);
 }
-function generateProjectId(projectPath) {
+function generateRepoId(projectPath) {
   const normalized = path.resolve(projectPath);
   const hash = crypto.createHash("sha256").update(normalized).digest("hex");
   return hash.slice(0, 12);
@@ -26,11 +27,31 @@ function generateProjectId(projectPath) {
 function createEmptyRegistry() {
   return {
     version: 1,
-    projects: {},
-    defaultProject: void 0
+    repos: {},
+    defaultRepo: void 0
   };
 }
-function loadProjectRegistry(baseDir = DEFAULT_BASE_DIR) {
+function migrateIfNeeded(baseDir) {
+  const newPath = registryPath(baseDir);
+  if (fs.existsSync(newPath)) return;
+  const legacyPath = path.join(baseDir, LEGACY_REGISTRY_FILE);
+  if (!fs.existsSync(legacyPath)) return;
+  try {
+    const raw = fs.readFileSync(legacyPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const migrated = {
+      version: 1,
+      repos: parsed.projects ?? parsed.repos ?? {},
+      defaultRepo: parsed.defaultProject ?? parsed.defaultRepo
+    };
+    fs.mkdirSync(path.dirname(newPath), { recursive: true });
+    atomicWrite(newPath, JSON.stringify(migrated, null, 2));
+    fs.unlinkSync(legacyPath);
+  } catch {
+  }
+}
+function loadRepoRegistry(baseDir = DEFAULT_BASE_DIR) {
+  migrateIfNeeded(baseDir);
   const filePath = registryPath(baseDir);
   if (!fs.existsSync(filePath)) {
     return createEmptyRegistry();
@@ -38,7 +59,7 @@ function loadProjectRegistry(baseDir = DEFAULT_BASE_DIR) {
   try {
     const raw = fs.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && parsed.version === 1 && typeof parsed.projects === "object") {
+    if (parsed && typeof parsed === "object" && parsed.version === 1 && typeof parsed.repos === "object") {
       return parsed;
     }
     return createEmptyRegistry();
@@ -46,17 +67,17 @@ function loadProjectRegistry(baseDir = DEFAULT_BASE_DIR) {
     return createEmptyRegistry();
   }
 }
-function saveProjectRegistry(registry, baseDir = DEFAULT_BASE_DIR) {
+function saveRepoRegistry(registry, baseDir = DEFAULT_BASE_DIR) {
   const filePath = registryPath(baseDir);
   const dir = path.dirname(filePath);
   fs.mkdirSync(dir, { recursive: true });
   atomicWrite(filePath, JSON.stringify(registry, null, 2));
 }
-function registerProject(projectDir, options = {}, baseDir = DEFAULT_BASE_DIR) {
+function registerRepo(projectDir, options = {}, baseDir = DEFAULT_BASE_DIR) {
   const absPath = path.resolve(projectDir);
-  const id = generateProjectId(absPath);
-  const registry = loadProjectRegistry(baseDir);
-  const existing = registry.projects[id];
+  const id = generateRepoId(absPath);
+  const registry = loadRepoRegistry(baseDir);
+  const existing = registry.repos[id];
   let configStatus = "none";
   const rulesPath = projectGuardsFile(absPath);
   const rulesYamlPath = projectGuardsFileAlt(absPath);
@@ -88,80 +109,80 @@ function registerProject(projectDir, options = {}, baseDir = DEFAULT_BASE_DIR) {
     hooksInstalled: options.hooksInstalled ?? hooksInstalled,
     stack: options.stack ?? existing?.stack
   };
-  registry.projects[id] = entry;
-  saveProjectRegistry(registry, baseDir);
+  registry.repos[id] = entry;
+  saveRepoRegistry(registry, baseDir);
   return entry;
 }
-function unregisterProject(idOrPath, baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  if (registry.projects[idOrPath]) {
-    delete registry.projects[idOrPath];
-    if (registry.defaultProject === idOrPath) {
-      registry.defaultProject = void 0;
+function unregisterRepo(idOrPath, baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  if (registry.repos[idOrPath]) {
+    delete registry.repos[idOrPath];
+    if (registry.defaultRepo === idOrPath) {
+      registry.defaultRepo = void 0;
     }
-    saveProjectRegistry(registry, baseDir);
+    saveRepoRegistry(registry, baseDir);
     return true;
   }
   const absPath = path.resolve(idOrPath);
-  const id = generateProjectId(absPath);
-  if (registry.projects[id]) {
-    delete registry.projects[id];
-    if (registry.defaultProject === id) {
-      registry.defaultProject = void 0;
+  const id = generateRepoId(absPath);
+  if (registry.repos[id]) {
+    delete registry.repos[id];
+    if (registry.defaultRepo === id) {
+      registry.defaultRepo = void 0;
     }
-    saveProjectRegistry(registry, baseDir);
+    saveRepoRegistry(registry, baseDir);
     return true;
   }
   return false;
 }
-function getProject(idOrPath, baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  if (registry.projects[idOrPath]) {
-    return registry.projects[idOrPath];
+function getRepo(idOrPath, baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  if (registry.repos[idOrPath]) {
+    return registry.repos[idOrPath];
   }
   const absPath = path.resolve(idOrPath);
-  const id = generateProjectId(absPath);
-  return registry.projects[id] ?? null;
+  const id = generateRepoId(absPath);
+  return registry.repos[id] ?? null;
 }
-function listProjects(baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  return Object.values(registry.projects).sort((a, b) => {
+function listRepos(baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  return Object.values(registry.repos).sort((a, b) => {
     return new Date(b.lastAccessed).getTime() - new Date(a.lastAccessed).getTime();
   });
 }
-function setDefaultProject(idOrPath, baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
+function setDefaultRepo(idOrPath, baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
   if (!idOrPath) {
-    registry.defaultProject = void 0;
-    saveProjectRegistry(registry, baseDir);
+    registry.defaultRepo = void 0;
+    saveRepoRegistry(registry, baseDir);
     return true;
   }
   let id = idOrPath;
-  if (!registry.projects[id]) {
+  if (!registry.repos[id]) {
     const absPath = path.resolve(idOrPath);
-    id = generateProjectId(absPath);
+    id = generateRepoId(absPath);
   }
-  if (!registry.projects[id]) {
+  if (!registry.repos[id]) {
     return false;
   }
-  registry.defaultProject = id;
-  saveProjectRegistry(registry, baseDir);
+  registry.defaultRepo = id;
+  saveRepoRegistry(registry, baseDir);
   return true;
 }
-function getDefaultProject(baseDir = DEFAULT_BASE_DIR) {
-  const registry = loadProjectRegistry(baseDir);
-  if (!registry.defaultProject) {
+function getDefaultRepo(baseDir = DEFAULT_BASE_DIR) {
+  const registry = loadRepoRegistry(baseDir);
+  if (!registry.defaultRepo) {
     return null;
   }
-  return registry.projects[registry.defaultProject] ?? null;
+  return registry.repos[registry.defaultRepo] ?? null;
 }
-function scanForProjects(rootDir, maxDepth = 3) {
-  const projects = [];
+function scanForRepos(rootDir, maxDepth = 3) {
+  const repos = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
     const ulpiPath = path.join(dir, ".ulpi");
     if (fs.existsSync(path.join(ulpiPath, "guards.yml")) || fs.existsSync(path.join(ulpiPath, "guards.yaml"))) {
-      projects.push(dir);
+      repos.push(dir);
       return;
     }
     try {
@@ -182,16 +203,16 @@ function scanForProjects(rootDir, maxDepth = 3) {
     }
   }
   scan(path.resolve(rootDir), 0);
-  return projects;
+  return repos;
 }
 
 export {
-  loadProjectRegistry,
-  registerProject,
-  unregisterProject,
-  getProject,
-  listProjects,
-  setDefaultProject,
-  getDefaultProject,
-  scanForProjects
+  loadRepoRegistry,
+  registerRepo,
+  unregisterRepo,
+  getRepo,
+  listRepos,
+  setDefaultRepo,
+  getDefaultRepo,
+  scanForRepos
 };

package/dist/chunk-WED4LM5N.js

@@ -0,0 +1,322 @@
+import {
+  installKiroSkill
+} from "./chunk-IZPJHSPX.js";
+import {
+  BUNDLED_SKILLS
+} from "./chunk-4ZPOZULQ.js";
+import {
+  getBinaryPath
+} from "./chunk-C7CLUQI6.js";
+
+// ../../packages/agent-installer/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as fs2 from "fs";
+import * as path2 from "path";
+function buildMcpServers() {
+  const binary = getBinaryPath();
+  return {
+    "ulpi-codemap": {
+      command: binary,
+      args: ["codemap", "serve"],
+      transportType: "stdio"
+    },
+    "ulpi-memory": {
+      command: binary,
+      args: ["memory", "serve"],
+      transportType: "stdio"
+    }
+  };
+}
+function kiroAgentsDir() {
+  return path.join(os.homedir(), ".kiro", "agents");
+}
+function kiroAgentPath(name) {
+  return path.join(kiroAgentsDir(), `${name}.json`);
+}
+function kiroSkillsDir(projectDir) {
+  return path.join(projectDir, ".kiro", "skills");
+}
+function buildHooks() {
+  const binary = getBinaryPath();
+  return {
+    agentSpawn: [{ command: `${binary} session-start` }],
+    preToolUse: [{ matcher: "*", command: `${binary} pre-tool` }],
+    postToolUse: [{ matcher: "*", command: `${binary} post-tool` }],
+    stop: [{ command: `${binary} stop` }]
+  };
+}
+function generateAgentConfig() {
+  return {
+    name: "ulpi-governance",
+    description: "ULPI-governed coding agent. Enforces rules from .ulpi/guards.yml, tracks sessions, captures memory, and provides CodeMap semantic search.",
+    tools: ["read", "write", "shell"],
+    allowedTools: ["read"],
+    hooks: buildHooks(),
+    resources: [
+      "skill://.kiro/skills/*/SKILL.md",
+      "file://.ulpi/guards.yml"
+    ],
+    mcpServers: buildMcpServers()
+  };
+}
+function installKiroHooks(mode) {
+  if (mode === "agent") {
+    const agentConfig = generateAgentConfig();
+    const agentPath = kiroAgentPath("ulpi-governance");
+    const dir2 = path.dirname(agentPath);
+    fs.mkdirSync(dir2, { recursive: true });
+    fs.writeFileSync(agentPath, JSON.stringify(agentConfig, null, 2) + "\n", "utf-8");
+    return { file: agentPath, agent: "ulpi-governance" };
+  }
+  const defaultPath = kiroAgentPath("kiro_default");
+  let config = {};
+  if (fs.existsSync(defaultPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(defaultPath, "utf-8"));
+    } catch {
+    }
+  }
+  config.hooks = buildHooks();
+  config.mcpServers = { ...config.mcpServers ?? {}, ...buildMcpServers() };
+  const dir = path.dirname(defaultPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(defaultPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return { file: defaultPath, agent: "kiro_default" };
+}
+function installKiroSkills(projectDir) {
+  let count = 0;
+  for (const skillInfo of BUNDLED_SKILLS) {
+    const skill = {
+      name: skillInfo.id,
+      path: skillInfo.filename,
+      source: "bundled",
+      description: skillInfo.description
+    };
+    const dirName = `ulpi-${skillInfo.id}`;
+    const skillDir = path.join(kiroSkillsDir(projectDir), dirName);
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (fs.existsSync(skillPath)) continue;
+    installKiroSkill(skill, projectDir, "repo");
+    count++;
+  }
+  return count;
+}
+function uninstallKiro(projectDir) {
+  let agentRemoved = false;
+  let skillsRemoved = 0;
+  let agentsRemoved = 0;
+  const agentPath = kiroAgentPath("ulpi-governance");
+  if (fs.existsSync(agentPath)) {
+    fs.unlinkSync(agentPath);
+    agentRemoved = true;
+  }
+  const skillsDir = kiroSkillsDir(projectDir);
+  if (fs.existsSync(skillsDir)) {
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("ulpi-")) {
+        fs.rmSync(path.join(skillsDir, entry.name), { recursive: true, force: true });
+        skillsRemoved++;
+      }
+    }
+  }
+  const claudeAgentsDir = path.join(projectDir, ".claude", "agents");
+  const kiroAgentsBase = path.join(projectDir, ".kiro", "agents");
+  if (fs.existsSync(claudeAgentsDir) && fs.existsSync(kiroAgentsBase)) {
+    const claudeEntries = fs.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      const kiroJson = path.join(kiroAgentsBase, `${agentName}.json`);
+      const kiroPromptDir = path.join(kiroAgentsBase, agentName);
+      if (fs.existsSync(kiroJson)) {
+        fs.unlinkSync(kiroJson);
+        agentsRemoved++;
+      }
+      if (fs.existsSync(kiroPromptDir)) {
+        fs.rmSync(kiroPromptDir, { recursive: true, force: true });
+      }
+    }
+  }
+  return { agentRemoved, skillsRemoved, agentsRemoved };
+}
+function getKiroStatus(projectDir) {
+  const agentPath = kiroAgentPath("ulpi-governance");
+  const agentInstalled = fs.existsSync(agentPath);
+  let skillCount = 0;
+  let convertedSkillCount = 0;
+  const skillsDir = kiroSkillsDir(projectDir);
+  if (fs.existsSync(skillsDir)) {
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name.startsWith("ulpi-")) {
+        skillCount++;
+      } else {
+        convertedSkillCount++;
+      }
+    }
+  }
+  let convertedAgentCount = 0;
+  const claudeAgentsDir = path.join(projectDir, ".claude", "agents");
+  const kiroAgentsBase = path.join(projectDir, ".kiro", "agents");
+  if (fs.existsSync(claudeAgentsDir) && fs.existsSync(kiroAgentsBase)) {
+    const claudeEntries = fs.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      if (fs.existsSync(path.join(kiroAgentsBase, `${agentName}.json`))) {
+        convertedAgentCount++;
+      }
+    }
+  }
+  const mcpPath = path.join(projectDir, ".kiro", "settings", "mcp.json");
+  let mcpConfigured = false;
+  if (fs.existsSync(mcpPath)) {
+    try {
+      const mcpConfig = JSON.parse(fs.readFileSync(mcpPath, "utf-8"));
+      const servers = mcpConfig.mcpServers;
+      mcpConfigured = !!(servers?.["ulpi-codemap"] || servers?.["ulpi-memory"]);
+    } catch {
+    }
+  }
+  return { agentInstalled, agentPath, skillCount, convertedSkillCount, convertedAgentCount, mcpConfigured };
+}
+function installCodexMcpServers(projectDir) {
+  const configPath = path2.join(projectDir, ".codex", "config.toml");
+  let content = "";
+  if (fs2.existsSync(configPath)) {
+    content = fs2.readFileSync(configPath, "utf-8");
+  }
+  const servers = buildMcpServers();
+  let added = 0;
+  for (const [name, entry] of Object.entries(servers)) {
+    const actualHeader = `[mcp_servers.${name}]`;
+    if (content.includes(actualHeader)) continue;
+    const argsToml = entry.args.map((a) => `"${a}"`).join(", ");
+    content += `
+${actualHeader}
+command = "${entry.command}"
+args = [${argsToml}]
+`;
+    added++;
+  }
+  if (added > 0) {
+    const dir = path2.dirname(configPath);
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(configPath, content, "utf-8");
+  }
+  return added;
+}
+function uninstallCodex(projectDir) {
+  let agentsRemoved = 0;
+  let skillsRemoved = 0;
+  let mcpRemoved = false;
+  const claudeAgentsDir = path2.join(projectDir, ".claude", "agents");
+  const codexAgentsBase = path2.join(projectDir, ".codex", "agents");
+  if (fs2.existsSync(claudeAgentsDir) && fs2.existsSync(codexAgentsBase)) {
+    const claudeEntries = fs2.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      const codexToml = path2.join(codexAgentsBase, `${agentName}.toml`);
+      const codexInstructionsDir = path2.join(codexAgentsBase, agentName);
+      if (fs2.existsSync(codexToml)) {
+        fs2.unlinkSync(codexToml);
+        agentsRemoved++;
+      }
+      if (fs2.existsSync(codexInstructionsDir)) {
+        fs2.rmSync(codexInstructionsDir, { recursive: true, force: true });
+      }
+    }
+  }
+  const claudeSkillsDir = path2.join(projectDir, ".claude", "skills");
+  const codexSkillsDir = path2.join(projectDir, ".codex", "skills");
+  if (fs2.existsSync(claudeSkillsDir) && fs2.existsSync(codexSkillsDir)) {
+    const claudeEntries = fs2.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    for (const entry of claudeEntries) {
+      if (!entry.isDirectory()) continue;
+      const codexSkillDir = path2.join(codexSkillsDir, entry.name);
+      if (fs2.existsSync(codexSkillDir)) {
+        fs2.rmSync(codexSkillDir, { recursive: true, force: true });
+        skillsRemoved++;
+      }
+    }
+  }
+  const configPath = path2.join(projectDir, ".codex", "config.toml");
+  if (fs2.existsSync(configPath)) {
+    let content = fs2.readFileSync(configPath, "utf-8");
+    const originalLen = content.length;
+    for (const name of ["ulpi-codemap", "ulpi-memory"]) {
+      const sectionRegex = new RegExp(
+        `\\n?\\[mcp_servers\\.${name.replace(/-/g, "\\-")}\\]\\n(?:[^\\[]*?)(?=\\n\\[|$)`,
+        "s"
+      );
+      content = content.replace(sectionRegex, "");
+    }
+    if (fs2.existsSync(claudeAgentsDir)) {
+      const claudeEntries = fs2.readdirSync(claudeAgentsDir);
+      for (const file of claudeEntries) {
+        if (!file.endsWith(".md")) continue;
+        const agentName = file.replace(/\.md$/, "");
+        const sectionRegex = new RegExp(
+          `\\n?\\[agents\\.${agentName}\\]\\n(?:[^\\[]*?)(?=\\n\\[|$)`,
+          "s"
+        );
+        content = content.replace(sectionRegex, "");
+      }
+    }
+    if (content.length !== originalLen) {
+      mcpRemoved = true;
+      fs2.writeFileSync(configPath, content.trim() + "\n", "utf-8");
+    }
+  }
+  return { agentsRemoved, skillsRemoved, mcpRemoved };
+}
+function getCodexStatus(projectDir) {
+  let convertedAgentCount = 0;
+  let convertedSkillCount = 0;
+  const claudeAgentsDir = path2.join(projectDir, ".claude", "agents");
+  const codexAgentsBase = path2.join(projectDir, ".codex", "agents");
+  if (fs2.existsSync(claudeAgentsDir) && fs2.existsSync(codexAgentsBase)) {
+    const claudeEntries = fs2.readdirSync(claudeAgentsDir);
+    for (const file of claudeEntries) {
+      if (!file.endsWith(".md")) continue;
+      const agentName = file.replace(/\.md$/, "");
+      if (fs2.existsSync(path2.join(codexAgentsBase, `${agentName}.toml`))) {
+        convertedAgentCount++;
+      }
+    }
+  }
+  const claudeSkillsDir = path2.join(projectDir, ".claude", "skills");
+  const codexSkillsDir = path2.join(projectDir, ".codex", "skills");
+  if (fs2.existsSync(claudeSkillsDir) && fs2.existsSync(codexSkillsDir)) {
+    const claudeEntries = fs2.readdirSync(claudeSkillsDir, { withFileTypes: true });
+    for (const entry of claudeEntries) {
+      if (!entry.isDirectory()) continue;
+      if (fs2.existsSync(path2.join(codexSkillsDir, entry.name, "SKILL.md"))) {
+        convertedSkillCount++;
+      }
+    }
+  }
+  const configPath = path2.join(projectDir, ".codex", "config.toml");
+  let mcpConfigured = false;
+  if (fs2.existsSync(configPath)) {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    mcpConfigured = content.includes("[mcp_servers.ulpi-codemap]") || content.includes("[mcp_servers.ulpi-memory]");
+  }
+  return { convertedAgentCount, convertedSkillCount, mcpConfigured };
+}
+
+export {
+  buildMcpServers,
+  installKiroHooks,
+  installKiroSkills,
+  uninstallKiro,
+  getKiroStatus,
+  installCodexMcpServers,
+  uninstallCodex,
+  getCodexStatus
+};