@askexenow/exe-os 0.8.0

package/dist/bin/install.js

@@ -0,0 +1,656 @@
+#!/usr/bin/env node
+
+// src/adapters/claude/installer.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir } from "fs/promises";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import path4 from "path";
+import os3 from "os";
+import { fileURLToPath } from "url";
+
+// src/lib/agent-symlinks.ts
+import os2 from "os";
+import path3 from "path";
+import {
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync,
+  readlinkSync as readlinkSync2,
+  symlinkSync as symlinkSync2
+} from "fs";
+
+// src/lib/employees.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2, symlinkSync, readlinkSync } from "fs";
+import { execSync } from "child_process";
+import path2 from "path";
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { readFileSync, existsSync, renameSync } from "fs";
+import path from "path";
+import os from "os";
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
+  const newDir = path.join(os.homedir(), ".exe-os");
+  const legacyDir = path.join(os.homedir(), ".exe-mem");
+  if (!existsSync(newDir) && existsSync(legacyDir)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+var EXE_AI_DIR = resolveDataDir();
+var DB_PATH = path.join(EXE_AI_DIR, "memories.db");
+var MODELS_DIR = path.join(EXE_AI_DIR, "models");
+var CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
+var LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
+var CURRENT_CONFIG_VERSION = 1;
+var DEFAULT_CONFIG = {
+  config_version: CURRENT_CONFIG_VERSION,
+  dbPath: DB_PATH,
+  modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+  embeddingDim: 1024,
+  batchSize: 20,
+  flushIntervalMs: 1e4,
+  autoIngestion: true,
+  autoRetrieval: true,
+  searchMode: "hybrid",
+  hookSearchMode: "hybrid",
+  fileGrepEnabled: true,
+  splashEffect: true,
+  consolidationEnabled: true,
+  consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+  consolidationModel: "claude-haiku-4-5-20251001",
+  consolidationMaxCallsPerRun: 20,
+  selfQueryRouter: true,
+  selfQueryModel: "claude-haiku-4-5-20251001",
+  rerankerEnabled: true,
+  scalingRoadmap: {
+    rerankerAutoTrigger: {
+      enabled: true,
+      broadQueryMinCardinality: 5e4,
+      fetchTopK: 150,
+      returnTopK: 5
+    }
+  },
+  graphRagEnabled: true,
+  wikiEnabled: false,
+  wikiUrl: "",
+  wikiApiKey: "",
+  wikiSyncIntervalMs: 30 * 60 * 1e3,
+  wikiWorkspaceMapping: {
+    exe: "Executive",
+    yoshi: "Engineering",
+    mari: "Marketing",
+    tom: "Engineering",
+    sasha: "Production"
+  },
+  wikiAutoUpdate: true,
+  wikiAutoUpdateThreshold: 0.5,
+  wikiAutoUpdateCreateNew: true,
+  skillLearning: true,
+  skillThreshold: 3,
+  skillModel: "claude-haiku-4-5-20251001",
+  exeHeartbeat: {
+    enabled: true,
+    intervalSeconds: 60,
+    staleInProgressThresholdHours: 2
+  },
+  sessionLifecycle: {
+    idleKillEnabled: true,
+    idleKillTicksRequired: 3,
+    idleKillIntercomAckWindowMs: 1e4,
+    maxAutoInstances: 10
+  }
+};
+
+// src/lib/employees.ts
+var EMPLOYEES_PATH = path2.join(EXE_AI_DIR, "exe-employees.json");
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+
+// src/lib/agent-symlinks.ts
+function claudeAgentsDir(homeDir) {
+  return path3.join(homeDir, ".claude", "agents");
+}
+function identitySourcePath(homeDir, agentId) {
+  return path3.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+}
+function claudeAgentLinkPath(homeDir, agentId) {
+  return path3.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+}
+function ensureAgentSymlink(agentId, homeDir = os2.homedir()) {
+  const target = identitySourcePath(homeDir, agentId);
+  const link = claudeAgentLinkPath(homeDir, agentId);
+  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync3(link)) {
+    let stat;
+    try {
+      stat = lstatSync(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "stat_failed" };
+    }
+    if (!stat.isSymbolicLink()) {
+      return { agentId, action: "conflict", target, link, conflict: "regular_file" };
+    }
+    let currentTarget;
+    try {
+      currentTarget = readlinkSync2(link);
+    } catch {
+      return { agentId, action: "conflict", target, link, conflict: "readlink_failed" };
+    }
+    if (currentTarget === target) {
+      return { agentId, action: "already_correct", target, link };
+    }
+    return { agentId, action: "conflict", target, link, conflict: `points_to:${currentTarget}` };
+  }
+  try {
+    symlinkSync2(target, link);
+  } catch (err) {
+    return {
+      agentId,
+      action: "conflict",
+      target,
+      link,
+      conflict: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { agentId, action: "created", target, link };
+}
+async function ensureAllAgentSymlinks(homeDir = os2.homedir()) {
+  const employees = await loadEmployees();
+  return employees.map((emp) => ensureAgentSymlink(emp.name, homeDir));
+}
+
+// src/lib/mcp-prefix.ts
+var MCP_PRIMARY_KEY = "exe-os";
+var MCP_LEGACY_KEY = "exe-mem";
+var MCP_TOOL_PREFIXES = [
+  `mcp__${MCP_PRIMARY_KEY}__`,
+  `mcp__${MCP_LEGACY_KEY}__`
+];
+function expandDualPrefixTools(shortNames) {
+  const out = [];
+  for (const name of shortNames) {
+    for (const prefix of MCP_TOOL_PREFIXES) {
+      out.push(prefix + name);
+    }
+  }
+  return out;
+}
+
+// src/adapters/claude/installer.ts
+function resolvePackageRoot() {
+  const thisFile = fileURLToPath(import.meta.url);
+  let dir = path4.dirname(thisFile);
+  const root = path4.parse(dir).root;
+  while (dir !== root) {
+    const pkgPath = path4.join(dir, "package.json");
+    if (existsSync4(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        if (pkg.name === "exe-os") return dir;
+      } catch {
+      }
+    }
+    dir = path4.dirname(dir);
+  }
+  return path4.resolve(path4.dirname(thisFile), "..", "..", "..");
+}
+async function copySlashCommands(packageRoot, homeDir = os3.homedir()) {
+  let copied = 0;
+  let skipped = 0;
+  const skillsBase = path4.join(homeDir, ".claude", "skills");
+  const exeDir = path4.join(packageRoot, "src", "commands", "exe");
+  if (existsSync4(exeDir)) {
+    const entries = await readdir(exeDir);
+    const mdFiles = entries.filter((f) => f.endsWith(".md"));
+    for (const file of mdFiles) {
+      const name = file.replace(".md", "");
+      const destDir = path4.join(skillsBase, `exe-${name}`);
+      await mkdir3(destDir, { recursive: true });
+      const srcPath = path4.join(exeDir, file);
+      const destPath = path4.join(destDir, "SKILL.md");
+      const result = await copyAsSkill(srcPath, destPath, `exe-${name}`);
+      if (result) copied++;
+      else skipped++;
+    }
+  }
+  const topLevelSrc = path4.join(packageRoot, "src", "commands", "exe.md");
+  if (existsSync4(topLevelSrc)) {
+    const destDir = path4.join(skillsBase, "exe");
+    await mkdir3(destDir, { recursive: true });
+    const destPath = path4.join(destDir, "SKILL.md");
+    const result = await copyAsSkill(topLevelSrc, destPath, "exe");
+    if (result) copied++;
+    else skipped++;
+  }
+  return { copied, skipped };
+}
+async function copyAsSkill(srcPath, destPath, skillName) {
+  let content = await readFile3(srcPath, "utf-8");
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (fmMatch?.[1]) {
+    const fm = fmMatch[1];
+    if (fm.includes("name:")) {
+      content = content.replace(
+        /^(---\n[\s\S]*?)name:\s*[^\n]+/,
+        `$1name: ${skillName}`
+      );
+    } else {
+      content = content.replace(/^---\n/, `---
+name: ${skillName}
+`);
+    }
+  }
+  if (existsSync4(destPath)) {
+    const existing = await readFile3(destPath, "utf-8");
+    if (existing === content) return false;
+  }
+  await writeFile3(destPath, content);
+  return true;
+}
+async function registerMcpServer(packageRoot, homeDir = os3.homedir()) {
+  const claudeJsonPath = path4.join(homeDir, ".claude.json");
+  let claudeJson = {};
+  if (existsSync4(claudeJsonPath)) {
+    try {
+      claudeJson = JSON.parse(await readFile3(claudeJsonPath, "utf-8"));
+    } catch {
+      claudeJson = {};
+    }
+  }
+  if (!claudeJson.mcpServers) {
+    claudeJson.mcpServers = {};
+  }
+  const newEntry = {
+    type: "stdio",
+    command: "node",
+    args: [path4.join(packageRoot, "dist", "mcp", "server.js")],
+    env: {}
+  };
+  const legacy = claudeJson.mcpServers[MCP_LEGACY_KEY];
+  const current = claudeJson.mcpServers[MCP_PRIMARY_KEY];
+  const currentMatches = current && JSON.stringify(current) === JSON.stringify(newEntry);
+  if (currentMatches && !legacy) {
+    return false;
+  }
+  claudeJson.mcpServers[MCP_PRIMARY_KEY] = newEntry;
+  if (legacy) {
+    delete claudeJson.mcpServers[MCP_LEGACY_KEY];
+  }
+  await writeFile3(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+  return true;
+}
+async function mergeHooks(packageRoot, homeDir = os3.homedir()) {
+  const settingsPath = path4.join(homeDir, ".claude", "settings.json");
+  let settings = {};
+  if (existsSync4(settingsPath)) {
+    try {
+      settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const hooksToRegister = [
+    {
+      event: "PostToolUse",
+      group: {
+        matcher: "Bash|Edit|Write|Read|Glob|Grep|Agent|mcp__.*",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "ingest.js")}"`
+          },
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "error-recall.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/ingest.js"
+    },
+    {
+      event: "SessionStart",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "session-start.js")}"`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: "dist/hooks/session-start.js"
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/prompt-submit.js"
+    },
+    {
+      event: "UserPromptSubmit",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"`,
+            timeout: 5e3
+          }
+        ]
+      },
+      marker: "dist/hooks/exe-heartbeat-hook.js"
+    },
+    {
+      event: "Stop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "stop.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/stop.js"
+    },
+    {
+      event: "PreToolUse",
+      group: {
+        matcher: "Write|Edit|Read|Bash",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/pre-tool-use.js"
+    },
+    {
+      event: "SubagentStop",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/subagent-stop.js"
+    },
+    {
+      event: "PreCompact",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "pre-compact.js")}"`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: "dist/hooks/pre-compact.js"
+    },
+    {
+      event: "SessionEnd",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "session-end.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/session-end.js"
+    },
+    {
+      event: "Notification",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "notification.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/notification.js"
+    },
+    {
+      event: "PostCompact",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "post-compact.js")}"`,
+            timeout: 1e4
+          }
+        ]
+      },
+      marker: "dist/hooks/post-compact.js"
+    },
+    {
+      event: "InstructionsLoaded",
+      group: {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${path4.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"`
+          }
+        ]
+      },
+      marker: "dist/hooks/instructions-loaded.js"
+    }
+  ];
+  let added = 0;
+  let skipped = 0;
+  for (const { event, group, marker } of hooksToRegister) {
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+    const existing = settings.hooks[event];
+    const alreadyExists = existing.some(
+      (g) => g.hooks.some((h) => h.command.includes(marker))
+    );
+    if (alreadyExists) {
+      skipped++;
+    } else {
+      existing.push(group);
+      added++;
+    }
+  }
+  const perms = settings.permissions;
+  if (!perms) {
+    settings.permissions = {};
+  }
+  const permissions = settings.permissions;
+  if (!Array.isArray(permissions.allow)) {
+    permissions.allow = [];
+  }
+  const toolNames = [
+    "store_memory",
+    "recall_my_memory",
+    "create_task",
+    "list_tasks",
+    "get_task",
+    "update_task",
+    "close_task",
+    "store_behavior",
+    "deactivate_behavior",
+    "send_message",
+    "get_identity",
+    "update_identity",
+    "ask_team_memory",
+    "get_session_context",
+    "create_reminder",
+    "complete_reminder",
+    "list_reminders",
+    "list_behaviors",
+    "query_relationships",
+    "commit_to_long_term_memory"
+  ];
+  const allowList = permissions.allow;
+  for (const tool of expandDualPrefixTools(toolNames)) {
+    if (!allowList.includes(tool)) {
+      allowList.push(tool);
+    }
+  }
+  await mkdir3(path4.dirname(settingsPath), { recursive: true });
+  await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return { added, skipped };
+}
+var EXE_SECTION_START = "<!-- exe-os:orchestration-start -->";
+var EXE_SECTION_END = "<!-- exe-os:orchestration-end -->";
+var ORCHESTRATION_RULES = `${EXE_SECTION_START}
+## exe-os Multi-Agent Orchestration (auto-managed \u2014 do not edit)
+
+These rules are injected by exe-os and override default behavior for multi-agent coordination.
+
+- **Session routing is deterministic.** When working in exeN (e.g. exe1), ALL employee sessions use the same number: yoshi-exe1, tom-exe1, mari-exe1. NEVER reference, consider, or dispatch to employee sessions from other project numbers. This is not a choice \u2014 it is a hard constraint.
+- **Always use create_task to assign work.** Never use messages, tmux send-keys, or ad-hoc instructions as a substitute for tasks.
+- **Never modify another agent's in-progress task.** Create a new task instead. Modifying active tasks causes race conditions.
+- **Chain of command:** founder \u2192 exe \u2192 yoshi \u2192 engineers. Exe does not assign directly to tom or other engineers below yoshi.
+- **Verify dispatch.** After every create_task, confirm the employee received and started the task via tmux capture-pane.
+${EXE_SECTION_END}`;
+async function injectOrchestrationRules(homeDir) {
+  const claudeDir = path4.join(homeDir, ".claude");
+  const claudeMdPath = path4.join(claudeDir, "CLAUDE.md");
+  await mkdir3(claudeDir, { recursive: true });
+  let existing = "";
+  try {
+    existing = await readFile3(claudeMdPath, "utf-8");
+  } catch {
+  }
+  const startIdx = existing.indexOf(EXE_SECTION_START);
+  const endIdx = existing.indexOf(EXE_SECTION_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const currentSection = existing.slice(startIdx, endIdx + EXE_SECTION_END.length);
+    if (currentSection === ORCHESTRATION_RULES) {
+      return "unchanged";
+    }
+    const updated = existing.slice(0, startIdx) + ORCHESTRATION_RULES + existing.slice(endIdx + EXE_SECTION_END.length);
+    await writeFile3(claudeMdPath, updated, "utf-8");
+    return "updated";
+  }
+  const separator = existing.length > 0 && !existing.endsWith("\n\n") ? "\n\n" : "";
+  await writeFile3(claudeMdPath, existing + separator + ORCHESTRATION_RULES + "\n", "utf-8");
+  return "injected";
+}
+async function runInstaller(homeDir) {
+  const packageRoot = resolvePackageRoot();
+  process.stderr.write(`exe-os installer v1.3.0
+`);
+  process.stderr.write(`Package root: ${packageRoot}
+
+`);
+  const cmdResult = await copySlashCommands(packageRoot, homeDir);
+  process.stderr.write(
+    `Slash commands: ${cmdResult.copied} copied, ${cmdResult.skipped} unchanged
+`
+  );
+  const mcpChanged = await registerMcpServer(packageRoot, homeDir);
+  process.stderr.write(
+    `MCP server: ${mcpChanged ? "registered" : "already registered"}
+`
+  );
+  const hookResult = await mergeHooks(packageRoot, homeDir);
+  process.stderr.write(
+    `Hooks: ${hookResult.added} added, ${hookResult.skipped} unchanged
+`
+  );
+  const resolvedHome = homeDir ?? os3.homedir();
+  const exeWorkspace = path4.join(resolvedHome, "exe");
+  if (!existsSync4(exeWorkspace)) {
+    try {
+      await mkdir3(path4.join(exeWorkspace, "content"), { recursive: true });
+      await mkdir3(path4.join(exeWorkspace, "operations"), { recursive: true });
+      await mkdir3(path4.join(exeWorkspace, "output"), { recursive: true });
+      process.stderr.write(
+        `Created ~/exe/ \u2014 your automation workspace for non-code projects
+`
+      );
+    } catch {
+    }
+  }
+  const claudeMdResult = await injectOrchestrationRules(resolvedHome);
+  process.stderr.write(
+    `CLAUDE.md orchestration: ${claudeMdResult}
+`
+  );
+  const symlinkResults = await ensureAllAgentSymlinks(resolvedHome);
+  process.stderr.write(
+    `Agent symlinks: ${summarizeSymlinkResults(symlinkResults)}
+`
+  );
+  process.stderr.write(`
+exe-os installed successfully.
+`);
+}
+function summarizeSymlinkResults(results) {
+  if (results.length === 0) return "no employees in roster";
+  const created = results.filter((r) => r.action === "created").length;
+  const already = results.filter((r) => r.action === "already_correct").length;
+  const conflicts = results.filter((r) => r.action === "conflict");
+  let summary = `${created} created, ${already} already linked`;
+  if (conflicts.length > 0) {
+    const details = conflicts.map((r) => `${r.agentId} (${r.conflict ?? "unknown"})`).join(", ");
+    summary += `, ${conflicts.length} conflict(s): ${details}`;
+  }
+  return summary;
+}
+
+// src/bin/install.ts
+var args = process.argv.slice(2);
+if (args.includes("--commands-only")) {
+  try {
+    const packageRoot = resolvePackageRoot();
+    const result = await copySlashCommands(packageRoot);
+    if (result.copied > 0) {
+      process.stderr.write(
+        `exe-os: ${result.copied} slash command(s) updated
+`
+      );
+    }
+  } catch {
+  }
+} else if (args.includes("--global")) {
+  try {
+    await runInstaller();
+  } catch (err) {
+    console.error(
+      "Installation failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(1);
+  }
+} else {
+  console.error("Usage: npx exe-os --global");
+  console.error(
+    "  Installs exe-os commands, MCP server, and hooks into ~/.claude/"
+  );
+  process.exit(1);
+}