@goondocks/myco 0.10.0 → 0.11.0

package/dist/chunk-LYFDTF7G.js

@@ -0,0 +1,792 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  LmStudioBackend,
+  OllamaBackend
+} from "./chunk-5SDH75YC.js";
+import {
+  closeDatabase,
+  initDatabase,
+  vaultDbPath
+} from "./chunk-MYX5NCRH.js";
+import {
+  DaemonClient
+} from "./chunk-YKOEMLJJ.js";
+
+// src/symbionts/installer.ts
+import fs from "fs";
+import path from "path";
+var MYCO_HOOK_COMMAND_PREFIX = "myco-run";
+function isMycoHookGroup(group) {
+  if (Array.isArray(group.hooks) && group.hooks.some((h) => h.command?.startsWith(MYCO_HOOK_COMMAND_PREFIX))) return true;
+  if (typeof group.command === "string" && group.command.startsWith(MYCO_HOOK_COMMAND_PREFIX)) return true;
+  return false;
+}
+var GITIGNORE_SKILLS_COMMENT = "# Myco skill symlinks (machine-specific)";
+var TEMPLATES_SUBDIR = "src/symbionts/templates";
+var SKILLS_SUBDIR = "skills";
+var CANONICAL_SKILLS_DIR = ".agents/skills";
+var MYCO_MCP_SERVER_NAME = "myco";
+var INSTRUCTIONS_STUB_MARKER = "Edit AGENTS.md, not this file";
+var INSTRUCTIONS_REF_START = "<!-- myco:agents-ref:start -->";
+var INSTRUCTIONS_REF_END = "<!-- myco:agents-ref:end -->";
+var INSTRUCTIONS_REF_BLOCK = `${INSTRUCTIONS_REF_START}
+> **Project intelligence:** This project uses [Myco](https://myco.sh). The canonical project rules are in [\`AGENTS.md\`](AGENTS.md) \u2014 read and follow it alongside this file.
+${INSTRUCTIONS_REF_END}
+
+`;
+var SymbiontInstaller = class {
+  constructor(manifest, projectRoot, packageRoot) {
+    this.manifest = manifest;
+    this.projectRoot = projectRoot;
+    this.packageRoot = packageRoot;
+  }
+  /** Load a JSON template file for this symbiont. Returns null if not found. */
+  loadTemplate(name) {
+    const candidates = [
+      path.join(this.packageRoot, TEMPLATES_SUBDIR, this.manifest.name, `${name}.json`),
+      // tsup preserves the src/ prefix under dist/, so the same subdir works in both layouts
+      path.join(this.packageRoot, "dist", TEMPLATES_SUBDIR, this.manifest.name, `${name}.json`)
+    ];
+    for (const filePath of candidates) {
+      try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      } catch {
+      }
+    }
+    return null;
+  }
+  /** Run all registration steps. */
+  install() {
+    const reg = this.manifest.registration;
+    const result = this.shouldBatchJsonTargets(reg) ? this.installBatchedJson(reg) : {
+      hooks: this.installHooks(),
+      mcp: this.installMcp(),
+      skills: this.installSkills(),
+      settings: this.installSettings(),
+      instructions: this.installInstructions()
+    };
+    this.updateGitignore();
+    return result;
+  }
+  /**
+   * Check if ALL non-null JSON targets share the same file (e.g., Gemini).
+   * Only batches when every target resolves to one path — partial overlaps
+   * (e.g., Claude Code: hooks+settings share but MCP is separate) use normal path.
+   */
+  shouldBatchJsonTargets(reg) {
+    if (!reg) return false;
+    const mcpFormat = reg.mcpFormat ?? "json";
+    if (mcpFormat !== "json") return false;
+    const targets = [reg.hooksTarget, reg.mcpTarget, reg.settingsTarget].filter(Boolean);
+    return targets.length > 1 && new Set(targets).size === 1;
+  }
+  /**
+   * Batched install for agents where hooks, MCP, and settings share one JSON file.
+   * Single read → apply all transforms in memory → single write.
+   */
+  installBatchedJson(reg) {
+    const targetPath = path.join(this.projectRoot, reg.hooksTarget ?? reg.mcpTarget ?? reg.settingsTarget);
+    let data = readJsonFile(targetPath);
+    let hooks = false, mcp = false, settings = false;
+    const hooksTemplate = reg.hooksTarget ? this.loadTemplate("hooks") : null;
+    if (hooksTemplate) {
+      const existingHooks = data.hooks ?? {};
+      const mergedHooks = {};
+      for (const [event, groups] of Object.entries(existingHooks)) {
+        const nonMyco = groups.filter((g) => !isMycoHookGroup(g));
+        if (nonMyco.length > 0) mergedHooks[event] = nonMyco;
+      }
+      for (const [event, groups] of Object.entries(hooksTemplate)) {
+        mergedHooks[event] = [...mergedHooks[event] ?? [], ...groups];
+      }
+      data.hooks = mergedHooks;
+      hooks = true;
+    }
+    const mcpTemplate = reg.mcpTarget ? this.loadTemplate("mcp") : null;
+    if (mcpTemplate) {
+      const servers = data.mcpServers ?? {};
+      for (const [name, def] of Object.entries(mcpTemplate)) {
+        servers[name] = def;
+      }
+      data.mcpServers = servers;
+      mcp = true;
+    }
+    const settingsTemplate = reg.settingsTarget ? this.loadTemplate("settings") : null;
+    if (settingsTemplate) {
+      data = deepMergeSettings(data, settingsTemplate);
+      settings = true;
+    }
+    writeJsonFile(targetPath, data);
+    return {
+      hooks,
+      mcp,
+      skills: this.installSkills(),
+      settings,
+      instructions: this.installInstructions()
+    };
+  }
+  /** Remove all Myco registration from this symbiont's project files. */
+  uninstall() {
+    const reg = this.manifest.registration;
+    const result = this.shouldBatchJsonTargets(reg) ? this.uninstallBatchedJson(reg) : {
+      hooks: this.uninstallHooks(),
+      mcp: this.uninstallMcp(),
+      skills: this.uninstallSkills(),
+      settings: this.uninstallSettings(),
+      instructions: this.uninstallInstructions()
+    };
+    this.cleanGitignore();
+    return result;
+  }
+  /**
+   * Batched uninstall for agents where hooks, MCP, and settings share one JSON file.
+   */
+  uninstallBatchedJson(reg) {
+    const targetPath = path.join(this.projectRoot, reg.hooksTarget ?? reg.mcpTarget ?? reg.settingsTarget);
+    const data = readJsonFile(targetPath);
+    if (Object.keys(data).length === 0) {
+      return { hooks: false, mcp: false, skills: this.uninstallSkills(), settings: false, instructions: this.uninstallInstructions() };
+    }
+    let hooks = false, mcp = false, settings = false;
+    if (reg.hooksTarget) {
+      const existingHooks = data.hooks ?? {};
+      if (Object.keys(existingHooks).length > 0) {
+        const cleaned = {};
+        for (const [event, groups] of Object.entries(existingHooks)) {
+          const nonMyco = groups.filter((g) => !isMycoHookGroup(g));
+          if (nonMyco.length > 0) cleaned[event] = nonMyco;
+        }
+        if (Object.keys(cleaned).length === 0) {
+          delete data.hooks;
+        } else {
+          data.hooks = cleaned;
+        }
+        hooks = true;
+      }
+    }
+    if (reg.mcpTarget) {
+      const servers = data.mcpServers ?? {};
+      if (servers[MYCO_MCP_SERVER_NAME]) {
+        delete servers[MYCO_MCP_SERVER_NAME];
+        if (Object.keys(servers).length === 0) delete data.mcpServers;
+        else data.mcpServers = servers;
+        mcp = true;
+      }
+    }
+    const settingsTemplate = reg.settingsTarget ? this.loadTemplate("settings") : null;
+    if (settingsTemplate) {
+      settings = deepRemoveSettings(data, settingsTemplate);
+    }
+    writeOrDeleteJsonFile(targetPath, data);
+    return { hooks, mcp, skills: this.uninstallSkills(), settings, instructions: this.uninstallInstructions() };
+  }
+  /**
+   * Ensure the instruction file references AGENTS.md.
+   * - File doesn't exist: write the full stub template.
+   * - File exists without reference: prepend a reference block.
+   * - File already has reference: skip (idempotent).
+   */
+  installInstructions() {
+    const reg = this.manifest.registration;
+    if (!reg?.instructionsFile) return false;
+    const targetPath = path.join(this.projectRoot, reg.instructionsFile);
+    let existing = null;
+    try {
+      existing = fs.readFileSync(targetPath, "utf-8");
+    } catch {
+    }
+    if (existing !== null) {
+      if (existing.includes(INSTRUCTIONS_REF_START) || existing.includes(INSTRUCTIONS_STUB_MARKER)) {
+        return false;
+      }
+      fs.writeFileSync(targetPath, INSTRUCTIONS_REF_BLOCK + existing, "utf-8");
+      return true;
+    }
+    const templateCandidates = [
+      path.join(this.packageRoot, "src/symbionts/templates/instructions-stub.md"),
+      path.join(this.packageRoot, "dist/src/symbionts/templates/instructions-stub.md")
+    ];
+    let stub = null;
+    for (const p of templateCandidates) {
+      try {
+        stub = fs.readFileSync(p, "utf-8");
+        break;
+      } catch {
+      }
+    }
+    if (!stub) return false;
+    stub = stub.replace("{agentDisplayName}", this.manifest.displayName);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, stub, "utf-8");
+    return true;
+  }
+  /**
+   * Remove Myco's instruction file reference.
+   * - If file is the full stub (only Myco content): delete it.
+   * - If file has user content + prepended reference: remove just the reference block.
+   */
+  uninstallInstructions() {
+    const reg = this.manifest.registration;
+    if (!reg?.instructionsFile) return false;
+    const targetPath = path.join(this.projectRoot, reg.instructionsFile);
+    let content;
+    try {
+      content = fs.readFileSync(targetPath, "utf-8");
+    } catch {
+      return false;
+    }
+    if (content.includes(INSTRUCTIONS_STUB_MARKER)) {
+      fs.unlinkSync(targetPath);
+      return true;
+    }
+    if (content.includes(INSTRUCTIONS_REF_START)) {
+      const startIdx = content.indexOf(INSTRUCTIONS_REF_START);
+      const endIdx = content.indexOf(INSTRUCTIONS_REF_END);
+      if (endIdx > startIdx) {
+        const afterEnd = endIdx + INSTRUCTIONS_REF_END.length;
+        const cleaned = (content.slice(0, startIdx) + content.slice(afterEnd)).replace(/^\n+/, "");
+        fs.writeFileSync(targetPath, cleaned, "utf-8");
+        return true;
+      }
+    }
+    return false;
+  }
+  /** List skill directory names from the package root. Returns empty array if not found. */
+  listSkillDirs() {
+    try {
+      return fs.readdirSync(path.join(this.packageRoot, SKILLS_SUBDIR), { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    } catch {
+      return [];
+    }
+  }
+  /** Add skill symlink paths to project .gitignore. */
+  updateGitignore() {
+    const reg = this.manifest.registration;
+    if (!reg?.skillsTarget) return;
+    const skillNames = this.listSkillDirs();
+    const entries = [
+      `${CANONICAL_SKILLS_DIR}/`,
+      ...reg.skillsTarget !== CANONICAL_SKILLS_DIR ? skillNames.map((name) => `${reg.skillsTarget}/${name}`) : []
+    ];
+    const gitignorePath = path.join(this.projectRoot, ".gitignore");
+    let existing = "";
+    try {
+      existing = fs.readFileSync(gitignorePath, "utf-8");
+    } catch {
+    }
+    const newEntries = entries.filter((e) => !existing.includes(e));
+    if (newEntries.length === 0) return;
+    const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+    const block = `${separator}
+${GITIGNORE_SKILLS_COMMENT}
+${newEntries.join("\n")}
+`;
+    fs.writeFileSync(gitignorePath, existing + block, "utf-8");
+  }
+  /**
+   * Merge hooks template into the target settings file.
+   * Replaces all Myco-owned hook groups; preserves non-Myco hooks.
+   */
+  installHooks() {
+    const reg = this.manifest.registration;
+    if (!reg?.hooksTarget) return false;
+    const template = this.loadTemplate("hooks");
+    if (!template) return false;
+    const targetPath = path.join(this.projectRoot, reg.hooksTarget);
+    const settings = readJsonFile(targetPath);
+    const existingHooks = settings.hooks ?? {};
+    const mergedHooks = {};
+    for (const [event, groups] of Object.entries(existingHooks)) {
+      const nonMycoGroups = groups.filter(
+        (group) => !isMycoHookGroup(group)
+      );
+      if (nonMycoGroups.length > 0) {
+        mergedHooks[event] = nonMycoGroups;
+      }
+    }
+    for (const [event, groups] of Object.entries(template)) {
+      mergedHooks[event] = [...mergedHooks[event] ?? [], ...groups];
+    }
+    settings.hooks = mergedHooks;
+    writeJsonFile(targetPath, settings);
+    return true;
+  }
+  /**
+   * Merge MCP server template into the target config file.
+   * Replaces the `myco` server entry; preserves other servers.
+   */
+  installMcp() {
+    const reg = this.manifest.registration;
+    if (!reg?.mcpTarget) return false;
+    const template = this.loadTemplate("mcp");
+    if (!template) return false;
+    const targetPath = path.join(this.projectRoot, reg.mcpTarget);
+    const mcpFormat = reg.mcpFormat ?? "json";
+    if (mcpFormat === "toml") {
+      return this.installMcpToml(targetPath, template);
+    }
+    return this.installMcpJson(targetPath, template);
+  }
+  /** Write MCP servers to a JSON config file. */
+  installMcpJson(targetPath, template) {
+    const config = readJsonFile(targetPath);
+    const servers = config.mcpServers ?? {};
+    for (const [name, def] of Object.entries(template)) {
+      servers[name] = def;
+    }
+    config.mcpServers = servers;
+    writeJsonFile(targetPath, config);
+    return true;
+  }
+  /** Write MCP servers to a TOML config file. */
+  installMcpToml(targetPath, template) {
+    let raw = "";
+    try {
+      raw = fs.readFileSync(targetPath, "utf-8");
+    } catch {
+    }
+    for (const [name, def] of Object.entries(template)) {
+      raw = buildTomlMcpSection(raw, name, def);
+    }
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, raw, "utf-8");
+    return true;
+  }
+  /**
+   * Create symlinks for skills through .agents/skills/ canonical layer.
+   * Canonical: .agents/skills/<name> -> <packageRoot>/skills/<name>
+   * Agent-specific: <skillsTarget>/<name> -> ../../.agents/skills/<name>
+   */
+  installSkills() {
+    const reg = this.manifest.registration;
+    if (!reg?.skillsTarget) return false;
+    const skillNames = this.listSkillDirs();
+    if (skillNames.length === 0) return false;
+    const skillsSrc = path.join(this.packageRoot, SKILLS_SUBDIR);
+    const canonicalDir = path.join(this.projectRoot, CANONICAL_SKILLS_DIR);
+    fs.mkdirSync(canonicalDir, { recursive: true });
+    for (const name of skillNames) {
+      const canonicalLink = path.join(canonicalDir, name);
+      const target = path.join(skillsSrc, name);
+      ensureSymlink(canonicalLink, target);
+    }
+    const agentSkillsDir = path.join(this.projectRoot, reg.skillsTarget);
+    const canonicalRel = path.relative(agentSkillsDir, canonicalDir);
+    if (reg.skillsTarget !== CANONICAL_SKILLS_DIR) {
+      fs.mkdirSync(agentSkillsDir, { recursive: true });
+      for (const name of skillNames) {
+        const agentLink = path.join(agentSkillsDir, name);
+        const relTarget = path.join(canonicalRel, name);
+        ensureSymlink(agentLink, relTarget);
+      }
+    }
+    return true;
+  }
+  /**
+   * Merge settings template into the target settings file.
+   * Deep merges objects and deduplicates arrays.
+   */
+  installSettings() {
+    const reg = this.manifest.registration;
+    if (!reg?.settingsTarget) return false;
+    const template = this.loadTemplate("settings");
+    if (!template) return false;
+    const targetPath = path.join(this.projectRoot, reg.settingsTarget);
+    const existing = readJsonFile(targetPath);
+    const merged = deepMergeSettings(existing, template);
+    writeJsonFile(targetPath, merged);
+    return true;
+  }
+  /**
+   * Remove Myco entries from the target settings file.
+   * Template-driven: loads the settings template and removes matching values.
+   * Arrays: filter out values present in the template.
+   * Objects: delete keys present in the template.
+   */
+  uninstallSettings() {
+    const reg = this.manifest.registration;
+    if (!reg?.settingsTarget) return false;
+    const template = this.loadTemplate("settings");
+    if (!template) return false;
+    const targetPath = path.join(this.projectRoot, reg.settingsTarget);
+    const settings = readJsonFile(targetPath);
+    if (Object.keys(settings).length === 0) return false;
+    const changed = deepRemoveSettings(settings, template);
+    if (!changed) return false;
+    writeOrDeleteJsonFile(targetPath, settings);
+    return true;
+  }
+  /** Remove Myco hook groups from the target settings file. */
+  uninstallHooks() {
+    const reg = this.manifest.registration;
+    if (!reg?.hooksTarget) return false;
+    const targetPath = path.join(this.projectRoot, reg.hooksTarget);
+    const settings = readJsonFile(targetPath);
+    const existingHooks = settings.hooks ?? {};
+    if (Object.keys(existingHooks).length === 0) return false;
+    const cleaned = {};
+    for (const [event, groups] of Object.entries(existingHooks)) {
+      const nonMyco = groups.filter(
+        (group) => !isMycoHookGroup(group)
+      );
+      if (nonMyco.length > 0) {
+        cleaned[event] = nonMyco;
+      }
+    }
+    if (Object.keys(cleaned).length === 0) {
+      delete settings.hooks;
+    } else {
+      settings.hooks = cleaned;
+    }
+    writeOrDeleteJsonFile(targetPath, settings);
+    return true;
+  }
+  /** Remove Myco MCP server entry from the target config file. */
+  uninstallMcp() {
+    const reg = this.manifest.registration;
+    if (!reg?.mcpTarget) return false;
+    const targetPath = path.join(this.projectRoot, reg.mcpTarget);
+    const mcpFormat = reg.mcpFormat ?? "json";
+    if (mcpFormat === "toml") {
+      return this.uninstallMcpToml(targetPath);
+    }
+    return this.uninstallMcpJson(targetPath);
+  }
+  uninstallMcpJson(targetPath) {
+    const config = readJsonFile(targetPath);
+    const servers = config.mcpServers ?? {};
+    if (!servers[MYCO_MCP_SERVER_NAME]) return false;
+    delete servers[MYCO_MCP_SERVER_NAME];
+    if (Object.keys(servers).length === 0) {
+      delete config.mcpServers;
+    } else {
+      config.mcpServers = servers;
+    }
+    writeOrDeleteJsonFile(targetPath, config);
+    return true;
+  }
+  uninstallMcpToml(targetPath) {
+    let raw = "";
+    try {
+      raw = fs.readFileSync(targetPath, "utf-8");
+    } catch {
+      return false;
+    }
+    const sectionHeader = `[mcp_servers.${MYCO_MCP_SERVER_NAME}]`;
+    if (!raw.includes(sectionHeader)) return false;
+    const startIdx = raw.indexOf(sectionHeader);
+    const endIdx = findTomlSectionEnd(raw, startIdx + sectionHeader.length, MYCO_MCP_SERVER_NAME);
+    const before = raw.slice(0, startIdx).trimEnd();
+    const after = raw.slice(endIdx).trimStart();
+    const updated = (before + (before && after ? "\n\n" : "") + after).trimEnd();
+    if (!updated.trim()) {
+      try {
+        fs.unlinkSync(targetPath);
+      } catch {
+      }
+    } else {
+      fs.writeFileSync(targetPath, updated + "\n", "utf-8");
+    }
+    return true;
+  }
+  /** Remove skill symlinks (canonical + agent-specific). */
+  uninstallSkills() {
+    const reg = this.manifest.registration;
+    if (!reg?.skillsTarget) return false;
+    const skillNames = this.listSkillDirs();
+    if (skillNames.length === 0) return false;
+    let removed = false;
+    if (reg.skillsTarget !== CANONICAL_SKILLS_DIR) {
+      for (const name of skillNames) {
+        const link = path.join(this.projectRoot, reg.skillsTarget, name);
+        try {
+          fs.unlinkSync(link);
+          removed = true;
+        } catch {
+        }
+      }
+      try {
+        fs.rmdirSync(path.join(this.projectRoot, reg.skillsTarget));
+      } catch {
+      }
+    }
+    const canonicalDir = path.join(this.projectRoot, CANONICAL_SKILLS_DIR);
+    for (const name of skillNames) {
+      const link = path.join(canonicalDir, name);
+      try {
+        fs.unlinkSync(link);
+        removed = true;
+      } catch {
+      }
+    }
+    try {
+      fs.rmdirSync(canonicalDir);
+    } catch {
+    }
+    try {
+      fs.rmdirSync(path.join(this.projectRoot, ".agents"));
+    } catch {
+    }
+    return removed;
+  }
+  /** Remove Myco entries from project .gitignore. */
+  cleanGitignore() {
+    const gitignorePath = path.join(this.projectRoot, ".gitignore");
+    let content = "";
+    try {
+      content = fs.readFileSync(gitignorePath, "utf-8");
+    } catch {
+      return;
+    }
+    const reg = this.manifest.registration;
+    const skillNames = reg?.skillsTarget && reg.skillsTarget !== CANONICAL_SKILLS_DIR ? this.listSkillDirs() : [];
+    const lines = content.split("\n");
+    const filtered = lines.filter((line) => {
+      if (line === GITIGNORE_SKILLS_COMMENT) return false;
+      if (line === `${CANONICAL_SKILLS_DIR}/`) return false;
+      if (skillNames.some((name) => line === `${reg.skillsTarget}/${name}`)) return false;
+      return true;
+    });
+    const cleaned = filtered.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    if (cleaned) {
+      fs.writeFileSync(gitignorePath, cleaned + "\n", "utf-8");
+    } else {
+      try {
+        fs.unlinkSync(gitignorePath);
+      } catch {
+      }
+    }
+  }
+};
+var TOML_SECTION_RE = /^\[([^\]]+)\]/;
+function findTomlSectionEnd(raw, searchStart, serverName) {
+  const subsectionPrefix = `mcp_servers.${serverName}.`;
+  const rawLines = raw.slice(searchStart).split("\n");
+  let offset = searchStart;
+  for (const line of rawLines) {
+    offset += line.length + 1;
+    const m = line.match(TOML_SECTION_RE);
+    if (m && !m[1].startsWith(subsectionPrefix) && m[1] !== `mcp_servers.${serverName}`) {
+      return offset - line.length - 1;
+    }
+  }
+  return raw.length;
+}
+function buildTomlMcpSection(raw, serverName, server) {
+  const sectionHeader = `[mcp_servers.${serverName}]`;
+  const lines = [sectionHeader];
+  for (const [key, val] of Object.entries(server)) {
+    if (key === "env" && typeof val === "object" && val !== null) continue;
+    if (typeof val === "string") {
+      lines.push(`${key} = "${val}"`);
+    } else if (Array.isArray(val)) {
+      lines.push(`${key} = [${val.map((v) => `"${v}"`).join(", ")}]`);
+    } else if (typeof val === "boolean") {
+      lines.push(`${key} = ${val}`);
+    }
+  }
+  const env = server.env;
+  if (env && Object.keys(env).length > 0) {
+    lines.push("");
+    lines.push(`[mcp_servers.${serverName}.env]`);
+    for (const [key, val] of Object.entries(env)) {
+      lines.push(`${key} = "${val}"`);
+    }
+  }
+  const block = lines.join("\n");
+  let updated;
+  if (raw.includes(sectionHeader)) {
+    const startIdx = raw.indexOf(sectionHeader);
+    const endIdx = findTomlSectionEnd(raw, startIdx + sectionHeader.length, serverName);
+    const before = raw.slice(0, startIdx).trimEnd();
+    const after = raw.slice(endIdx);
+    const separator = before ? "\n\n" : "";
+    updated = (before + separator + block + after).trimEnd() + "\n";
+  } else {
+    const separator = raw.trim() ? "\n\n" : "";
+    updated = (raw.trimEnd() + separator + block).trimEnd() + "\n";
+  }
+  return updated;
+}
+function deepMergeSettings(target, source) {
+  const result = { ...target };
+  for (const [key, sourceVal] of Object.entries(source)) {
+    const targetVal = result[key];
+    if (Array.isArray(sourceVal) && Array.isArray(targetVal)) {
+      result[key] = [.../* @__PURE__ */ new Set([...targetVal, ...sourceVal])];
+    } else if (isPlainObject(sourceVal) && isPlainObject(targetVal)) {
+      result[key] = deepMergeSettings(
+        targetVal,
+        sourceVal
+      );
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function deepRemoveSettings(target, template) {
+  let changed = false;
+  for (const [key, templateVal] of Object.entries(template)) {
+    const targetVal = target[key];
+    if (targetVal === void 0) continue;
+    if (Array.isArray(templateVal) && Array.isArray(targetVal)) {
+      const templateSet = new Set(templateVal.map(String));
+      const filtered = targetVal.filter((v) => !templateSet.has(String(v)));
+      if (filtered.length !== targetVal.length) {
+        if (filtered.length > 0) {
+          target[key] = filtered;
+        } else {
+          delete target[key];
+        }
+        changed = true;
+      }
+    } else if (isPlainObject(templateVal) && isPlainObject(targetVal)) {
+      if (deepRemoveSettings(targetVal, templateVal)) {
+        if (Object.keys(targetVal).length === 0) {
+          delete target[key];
+        }
+        changed = true;
+      }
+    } else {
+      if (String(targetVal) === String(templateVal)) {
+        delete target[key];
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function writeOrDeleteJsonFile(filePath, data) {
+  if (Object.keys(data).length === 0) {
+    try {
+      fs.unlinkSync(filePath);
+    } catch {
+    }
+  } else {
+    writeJsonFile(filePath, data);
+  }
+}
+function ensureSymlink(linkPath, target) {
+  try {
+    if (fs.readlinkSync(linkPath) === target) return;
+  } catch {
+  }
+  try {
+    fs.rmSync(linkPath, { recursive: true, force: true });
+  } catch {
+  }
+  fs.symlinkSync(target, linkPath);
+}
+
+// src/cli/shared.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+function initVaultDb(vaultDir) {
+  initDatabase(vaultDbPath(vaultDir));
+  return closeDatabase;
+}
+async function connectToDaemon(vaultDir) {
+  const client = new DaemonClient(vaultDir);
+  const healthy = await client.ensureRunning();
+  if (!healthy) {
+    console.error("Failed to connect to daemon");
+    process.exit(1);
+  }
+  return client;
+}
+function loadEnv() {
+  const envPath = path2.resolve(process.cwd(), ".env");
+  if (!fs2.existsSync(envPath)) return;
+  for (const line of fs2.readFileSync(envPath, "utf-8").split("\n")) {
+    const match = line.match(/^\s*([^#=]+?)\s*=\s*(.*?)\s*$/);
+    if (match && !process.env[match[1]]) {
+      process.env[match[1]] = match[2];
+    }
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PROVIDER_DEFAULTS = {
+  ollama: { base_url: OllamaBackend.DEFAULT_BASE_URL },
+  "lm-studio": { base_url: LmStudioBackend.DEFAULT_BASE_URL }
+};
+var VAULT_GITIGNORE = `# SQLite database
+myco.db*
+vectors.db*
+
+# Daemon state \u2014 per-machine, ephemeral
+daemon.json
+buffer/
+logs/
+
+# Secrets \u2014 API keys for cloud providers
+secrets.env
+
+# Machine ID
+machine_id
+
+# Binary attachments \u2014 screenshots captured from transcripts
+attachments/
+
+# Team worker deployment \u2014 patched wrangler.toml + source copy
+.team-worker/
+`;
+function registerSymbionts(manifests, projectRoot, packageRoot, verb) {
+  let count = 0;
+  for (const manifest of manifests) {
+    try {
+      const installer = new SymbiontInstaller(manifest, projectRoot, packageRoot);
+      const result = installer.install();
+      const installed = [
+        result.hooks && "hooks",
+        result.mcp && "MCP server",
+        result.skills && "skills",
+        result.settings && "settings",
+        result.instructions && "instructions"
+      ].filter(Boolean);
+      if (installed.length > 0) {
+        console.log(`  \u2713 ${verb} ${manifest.displayName}: ${installed.join(", ")}`);
+        count++;
+      } else {
+        console.log(`  \u2013 ${manifest.displayName}: no registration targets configured`);
+      }
+    } catch (err) {
+      console.error(`  \u2717 Failed to register ${manifest.displayName}: ${err.message}`);
+    }
+  }
+  return count;
+}
+
+export {
+  MYCO_MCP_SERVER_NAME,
+  SymbiontInstaller,
+  initVaultDb,
+  connectToDaemon,
+  loadEnv,
+  isProcessAlive,
+  VAULT_GITIGNORE,
+  registerSymbionts
+};
+//# sourceMappingURL=chunk-LYFDTF7G.js.map