@vitld/meld-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1423 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command7 } from "commander";
+
+// src/cli/gen.ts
+import { Command } from "commander";
+
+// src/generate.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join5 } from "path";
+
+// src/config/loader.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+
+// src/config/schema.ts
+var VALID_AGENTS = ["claude-code", "codex-cli", "gemini-cli"];
+function validateConfig(input) {
+  const errors = [];
+  if (typeof input !== "object" || input === null) {
+    return { ok: false, errors: ["Config must be an object"] };
+  }
+  const obj = input;
+  const requiredKeys = ["projects", "agents", "mcp", "ide"];
+  for (const key of requiredKeys) {
+    if (!(key in obj)) {
+      errors.push(`Missing required key: ${key}`);
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  const agents = obj.agents;
+  for (const name of Object.keys(agents)) {
+    if (!VALID_AGENTS.includes(name)) {
+      errors.push(`Invalid agent name: ${name}. Must be one of: ${VALID_AGENTS.join(", ")}`);
+    }
+    const agent = agents[name];
+    if ("overrides" in agent && agent.overrides != null && (typeof agent.overrides !== "object" || Array.isArray(agent.overrides))) {
+      errors.push(`Agent "${name}" overrides must be an object`);
+    }
+  }
+  const mcp = obj.mcp;
+  for (const [serverName, server] of Object.entries(mcp)) {
+    const s = server;
+    if (s.type === "http") {
+      if (typeof s.url !== "string" || !s.url) {
+        errors.push(`MCP server "${serverName}" (http) must have a "url" string`);
+      }
+    } else {
+      if (typeof s.command !== "string" || !s.command) {
+        errors.push(`MCP server "${serverName}" (stdio) must have a "command" string`);
+      }
+      if (!Array.isArray(s.args)) {
+        errors.push(`MCP server "${serverName}" (stdio) must have an "args" array`);
+      }
+    }
+    if (s.agents && Array.isArray(s.agents)) {
+      for (const agent of s.agents) {
+        if (!VALID_AGENTS.includes(agent)) {
+          errors.push(`MCP server "${serverName}" has invalid agent scope: ${agent}`);
+        }
+      }
+    }
+  }
+  if ("context" in obj && obj.context != null) {
+    if (typeof obj.context !== "string") {
+      errors.push("context must be a string path");
+    }
+  }
+  if (errors.length > 0) {
+    return { ok: false, errors };
+  }
+  return { ok: true, config: input };
+}
+
+// src/config/loader.ts
+function loadConfig(hubDir) {
+  const configPath = join(hubDir, "meld.jsonc");
+  if (!existsSync(configPath)) {
+    return { ok: false, errors: [`Config file not found: ${configPath}`] };
+  }
+  let raw;
+  try {
+    raw = readFileSync(configPath, "utf-8");
+  } catch (err) {
+    return {
+      ok: false,
+      errors: [`Failed to read config: ${err.message}`]
+    };
+  }
+  let parsed;
+  const parseErrors = [];
+  parsed = parseJsonc(raw, parseErrors);
+  if (parseErrors.length > 0) {
+    return {
+      ok: false,
+      errors: [`Invalid JSONC in meld.jsonc: ${parseErrors.length} parse error(s)`]
+    };
+  }
+  return validateConfig(parsed);
+}
+
+// src/config/interpolate.ts
+var ENV_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)}/g;
+function interpolateEnv(config) {
+  const warnings = [];
+  const resolved = deepInterpolate(config, warnings);
+  return { config: resolved, warnings };
+}
+function deepInterpolate(value, warnings) {
+  if (typeof value === "string") {
+    return value.replace(ENV_PATTERN, (match, varName) => {
+      const envValue = process.env[varName];
+      if (envValue === void 0) {
+        warnings.push(`Environment variable not set: ${varName}`);
+        return match;
+      }
+      return envValue;
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepInterpolate(item, warnings));
+  }
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = deepInterpolate(val, warnings);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/context/composer.ts
+import { readdirSync, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, basename, extname, relative } from "path";
+
+// src/config/types.ts
+var AGENTS_DIR = "agents";
+var DEFAULT_AGENT_DIRS = {
+  "claude-code": "claude-code",
+  "codex-cli": "codex",
+  "gemini-cli": "gemini"
+};
+function resolveAgentDir(name, agentConfig) {
+  return agentConfig.dir ?? DEFAULT_AGENT_DIRS[name];
+}
+function isHttpMcp(server) {
+  return server.type === "http";
+}
+var DEFAULT_CONTEXT_PATH = "./context/";
+function resolveContextPath(contextPath) {
+  return contextPath ?? DEFAULT_CONTEXT_PATH;
+}
+
+// src/context/composer.ts
+function composeContext(hubDir, config) {
+  const { inline, contextFiles } = readContext(hubDir, config);
+  return {
+    hubDir,
+    hubPreamble: buildHubPreamble(config),
+    projectTable: buildProjectTable(config),
+    artifactsSection: buildArtifactsSection(),
+    context: inline,
+    contextFiles,
+    commands: readCommands(hubDir),
+    skills: readSkills(hubDir)
+  };
+}
+function buildHubPreamble(config) {
+  return [
+    `# ${config.ide.workspaceName}`,
+    "",
+    "This is a **meld hub** \u2014 a multi-project workspace with shared configuration generated by [meld](https://github.com/vitld/meld-cli).",
+    "",
+    "You are running from a subfolder of the hub (`agents/<name>/`). The hub root is at `../../`.",
+    "",
+    "## Hub Structure",
+    "",
+    "| Path | Purpose |",
+    "|------|---------|",
+    "| `meld.jsonc` | Central config \u2014 projects, agents, MCP servers |",
+    "| `context/` | Agent instructions \u2014 root `.md` files are inlined, subfolders are copied |",
+    "| `commands/` | Slash commands available to agents |",
+    "| `skills/` | Reusable skills with frontmatter metadata |",
+    "| `artifacts/` | Persistent research, plans, and notes |",
+    "| `scratch/` | Temporary work (gitignored) |",
+    "| `agents/` | Generated output \u2014 **do not edit**, regenerated by `meld gen` |",
+    "",
+    "> To change workspace settings, edit `meld.jsonc` at the hub root and run `meld gen` to regenerate."
+  ].join("\n");
+}
+function buildProjectTable(config) {
+  const projects = buildProjectIndex(config);
+  if (projects.length === 0) return "";
+  const lines = [
+    "## Projects",
+    "",
+    "| Project | Aliases | Path | Repo |",
+    "|---------|---------|------|------|"
+  ];
+  for (const project of projects) {
+    lines.push(
+      `| ${project.name} | ${project.aliases.join(", ")} | ${project.path} | ${project.repo ?? ""} |`
+    );
+  }
+  return lines.join("\n");
+}
+function buildArtifactsSection() {
+  return [
+    "## Artifacts & Scratch",
+    "",
+    "- Hub-scoped artifacts: `../../artifacts/hub/`",
+    "- Per-project artifacts: `../../artifacts/projects/{project-name}/`",
+    "- Scratch (temporary work, gitignored): `../../scratch/`",
+    "",
+    "> Save research, plans, and notes to the appropriate artifacts folder."
+  ].join("\n");
+}
+function buildProjectIndex(config) {
+  return Object.entries(config.projects).map(([name, project]) => ({
+    name,
+    aliases: project.aliases,
+    path: project.path,
+    ...project.repo && { repo: project.repo }
+  }));
+}
+function readContext(hubDir, config) {
+  const contextPath = resolveContextPath(config.context);
+  const dir = join2(hubDir, contextPath);
+  if (!existsSync2(dir)) return { inline: "", contextFiles: [] };
+  const entries = readdirSync(dir, { withFileTypes: true });
+  const mdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name).sort();
+  const inline = mdFiles.length > 0 ? mdFiles.map((f) => readFileSync2(join2(dir, f), "utf-8").trim()).join("\n\n") : "";
+  const contextFiles = [];
+  const subdirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  for (const subdir of subdirs) {
+    collectFiles(join2(dir, subdir), dir, contextFiles);
+  }
+  return { inline, contextFiles };
+}
+function collectFiles(dirPath, relativeTo, out) {
+  const entries = readdirSync(dirPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const fullPath = join2(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(fullPath, relativeTo, out);
+    } else if (entry.isFile()) {
+      out.push({
+        path: relative(relativeTo, fullPath),
+        content: readFileSync2(fullPath, "utf-8")
+      });
+    }
+  }
+}
+function readCommands(hubDir) {
+  const commandsDir = join2(hubDir, "commands");
+  if (!existsSync2(commandsDir)) return [];
+  return readdirSync(commandsDir).filter((f) => f.endsWith(".md")).sort().map((f) => ({
+    name: basename(f, extname(f)),
+    content: readFileSync2(join2(commandsDir, f), "utf-8")
+  }));
+}
+function readSkills(hubDir) {
+  const skillsDir = join2(hubDir, "skills");
+  if (!existsSync2(skillsDir)) return [];
+  return readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).sort((a, b) => a.name.localeCompare(b.name)).map((d) => {
+    const skillFile = join2(skillsDir, d.name, "SKILL.md");
+    if (!existsSync2(skillFile)) return null;
+    const raw = readFileSync2(skillFile, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(raw);
+    return { name: d.name, frontmatter, body };
+  }).filter((s) => s !== null);
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+  const yamlStr = match[1];
+  const body = match[2].trim();
+  const frontmatter = parseSimpleYaml(yamlStr);
+  return { frontmatter, body };
+}
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  let currentKey = "";
+  let currentMap = null;
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    const indentedMatch = line.match(/^  (\w[\w-]*): (.+)$/);
+    if (indentedMatch && currentKey) {
+      if (!currentMap) currentMap = {};
+      currentMap[indentedMatch[1]] = indentedMatch[2].trim();
+      continue;
+    }
+    if (currentMap && currentKey) {
+      result[currentKey] = currentMap;
+      currentMap = null;
+    }
+    const topMatch = line.match(/^(\w[\w-]*): (.+)$/);
+    if (topMatch) {
+      currentKey = topMatch[1];
+      const value = topMatch[2].trim();
+      if (value.startsWith("[") && value.endsWith("]")) {
+        result[currentKey] = value.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
+      } else if (value === "true") {
+        result[currentKey] = true;
+      } else if (value === "false") {
+        result[currentKey] = false;
+      } else {
+        result[currentKey] = value.replace(/^["']|["']$/g, "");
+      }
+      continue;
+    }
+    const mapKeyMatch = line.match(/^(\w[\w-]*):$/);
+    if (mapKeyMatch) {
+      currentKey = mapKeyMatch[1];
+      currentMap = {};
+      continue;
+    }
+  }
+  if (currentMap && currentKey) {
+    result[currentKey] = currentMap;
+  }
+  return result;
+}
+
+// src/generators/writer.ts
+import { writeFileSync, mkdirSync } from "fs";
+import { join as join3, dirname } from "path";
+function writeGeneratedFiles(hubDir, files, options = {}) {
+  if (!options.dryRun) {
+    for (const file of files) {
+      const fullPath = join3(hubDir, file.path);
+      mkdirSync(dirname(fullPath), { recursive: true });
+      writeFileSync(fullPath, file.content);
+    }
+  }
+  return files;
+}
+
+// src/generators/utils.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, overrides) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(overrides)) {
+    const current = merged[key];
+    if (isPlainObject(current) && isPlainObject(value)) {
+      merged[key] = deepMerge(current, value);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function serializeToml(config) {
+  const lines = [];
+  appendTable([], config, lines);
+  return `${lines.join("\n")}
+`;
+}
+function appendTable(path, table, lines) {
+  const entries = Object.entries(table).filter(([, value]) => value !== void 0 && value !== null);
+  const scalarEntries = entries.filter(([, value]) => !isPlainObject(value));
+  const tableEntries = entries.filter(([, value]) => isPlainObject(value));
+  if (path.length > 0 && scalarEntries.length === 0 && tableEntries.length === 0) {
+    return;
+  }
+  if (path.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`[${path.map(escapeTomlKey).join(".")}]`);
+  }
+  for (const [key, value] of scalarEntries) {
+    lines.push(`${escapeTomlKey(key)} = ${formatTomlValue(value)}`);
+  }
+  for (const [key, value] of tableEntries) {
+    appendTable([...path, key], value, lines);
+  }
+}
+function formatTomlValue(value) {
+  if (typeof value === "string") return `"${escapeTomlString(value)}"`;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Cannot serialize non-finite number to TOML: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => formatTomlArrayValue(item)).join(", ")}]`;
+  }
+  throw new Error(`Unsupported TOML value type: ${typeof value}`);
+}
+function formatTomlArrayValue(value) {
+  if (typeof value === "string") return `"${escapeTomlString(value)}"`;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Cannot serialize non-finite number to TOML: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "boolean") return value ? "true" : "false";
+  throw new Error(`Unsupported TOML array value type: ${typeof value}`);
+}
+function escapeTomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : `"${escapeTomlString(key)}"`;
+}
+function escapeTomlString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+
+// src/generators/claude-code.ts
+var ClaudeCodeGenerator = class {
+  name = "claude-code";
+  generate(config, context) {
+    const files = [];
+    files.push({
+      path: "CLAUDE.md",
+      content: this.buildInstructions(context)
+    });
+    files.push({
+      path: ".mcp.json",
+      content: this.buildMcpConfig(config)
+    });
+    files.push({
+      path: ".claude/settings.json",
+      content: this.buildSettings(config, context.hubDir)
+    });
+    for (const command of context.commands) {
+      files.push({
+        path: `.claude/commands/meld/${command.name}.md`,
+        content: command.content
+      });
+    }
+    for (const skill of context.skills) {
+      files.push({
+        path: `.claude/skills/meld-${skill.name}/SKILL.md`,
+        content: this.buildSkill(skill)
+      });
+    }
+    for (const file of context.contextFiles) {
+      files.push({ path: file.path, content: file.content });
+    }
+    return files;
+  }
+  buildInstructions(context) {
+    const sections = [context.hubPreamble];
+    if (context.projectTable) {
+      sections.push(context.projectTable);
+    }
+    sections.push(context.artifactsSection);
+    if (context.context) {
+      sections.push(context.context);
+    }
+    return sections.join("\n\n");
+  }
+  buildMcpConfig(config) {
+    const servers = {};
+    for (const [name, server] of Object.entries(config.mcp)) {
+      if (server.agents && !server.agents.includes("claude-code")) continue;
+      if (isHttpMcp(server)) {
+        const entry = { type: "http", url: server.url };
+        if (server.headers) entry.headers = server.headers;
+        if (server.env) entry.env = server.env;
+        servers[name] = entry;
+      } else {
+        const entry = { command: server.command, args: server.args };
+        if (server.env) entry.env = server.env;
+        servers[name] = entry;
+      }
+    }
+    return JSON.stringify({ mcpServers: servers }, null, 2);
+  }
+  buildSettings(config, hubDir) {
+    const settings = {};
+    settings.env = { ENABLE_TOOL_SEARCH: "true" };
+    const allow = [];
+    const safeTools = ["Task", "WebSearch", "WebFetch", "ToolSearch"];
+    allow.push(...safeTools);
+    const safeBashCommands = [
+      "cd",
+      "ls",
+      "mkdir",
+      "cp",
+      "mv",
+      "cat",
+      "git",
+      "gh",
+      "node",
+      "npx",
+      "npm",
+      "yarn",
+      "pnpm",
+      "bun",
+      "which",
+      "pwd",
+      "ast-grep"
+    ];
+    for (const cmd of safeBashCommands) {
+      allow.push(`Bash(command:${cmd} *)`);
+    }
+    allow.push(`Read(//${hubDir}/**)`);
+    allow.push(`Glob(//${hubDir}/**)`);
+    allow.push(`Grep(//${hubDir}/**)`);
+    allow.push(`Write(//${hubDir}/**)`);
+    allow.push(`Edit(//${hubDir}/**)`);
+    const additionalDirectories = [];
+    for (const [, project] of Object.entries(config.projects)) {
+      allow.push(`Read(//${project.path}/**)`);
+      allow.push(`Glob(//${project.path}/**)`);
+      allow.push(`Grep(//${project.path}/**)`);
+      allow.push(`Write(//${project.path}/**)`);
+      allow.push(`Edit(//${project.path}/**)`);
+      additionalDirectories.push(project.path);
+    }
+    settings.permissions = { allow, additionalDirectories };
+    const overrides = config.agents["claude-code"].overrides;
+    const mergedSettings = isPlainObject(overrides) ? deepMerge(settings, overrides) : settings;
+    return JSON.stringify(mergedSettings, null, 2);
+  }
+  buildSkill(skill) {
+    const fm = { ...skill.frontmatter };
+    if (fm.model && typeof fm.model === "object" && !Array.isArray(fm.model)) {
+      const modelMap = fm.model;
+      if (modelMap["claude-code"]) {
+        fm.model = modelMap["claude-code"];
+      } else {
+        delete fm.model;
+      }
+    }
+    const frontmatterLines = this.serializeFrontmatter(fm);
+    return `---
+${frontmatterLines}
+---
+
+${skill.body}`;
+  }
+  serializeFrontmatter(fm) {
+    const lines = [];
+    for (const [key, value] of Object.entries(fm)) {
+      if (typeof value === "string") {
+        lines.push(`${key}: ${value}`);
+      } else if (typeof value === "boolean") {
+        lines.push(`${key}: ${value}`);
+      } else if (Array.isArray(value)) {
+        lines.push(`${key}: [${value.join(", ")}]`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/generators/codex-cli.ts
+var CodexCliGenerator = class {
+  name = "codex-cli";
+  generate(config, context) {
+    const files = [];
+    files.push({
+      path: "AGENTS.md",
+      content: this.buildInstructions(context)
+    });
+    files.push({
+      path: ".codex/config.toml",
+      content: this.buildConfigToml(config, context)
+    });
+    for (const command of context.commands) {
+      files.push({
+        path: `.agents/skills/meld-cmd-${command.name}/SKILL.md`,
+        content: command.content
+      });
+    }
+    for (const skill of context.skills) {
+      files.push({
+        path: `.agents/skills/meld-${skill.name}/SKILL.md`,
+        content: this.buildSkill(skill)
+      });
+    }
+    for (const file of context.contextFiles) {
+      files.push({ path: file.path, content: file.content });
+    }
+    return files;
+  }
+  buildInstructions(context) {
+    const sections = [context.hubPreamble];
+    if (context.projectTable) {
+      sections.push(context.projectTable);
+    }
+    sections.push(context.artifactsSection);
+    if (context.context) {
+      sections.push(context.context);
+    }
+    return sections.join("\n\n");
+  }
+  buildConfigToml(config, context) {
+    const writableRoots = Array.from(/* @__PURE__ */ new Set([
+      context.hubDir,
+      ...Object.values(config.projects).map((project) => project.path)
+    ]));
+    const generatedConfig = {
+      approval_policy: "on-request",
+      sandbox_mode: "workspace-write",
+      sandbox_workspace_write: {
+        writable_roots: writableRoots
+      }
+    };
+    const mcpServers = this.buildMcpServers(config);
+    if (Object.keys(mcpServers).length > 0) {
+      generatedConfig.mcp_servers = mcpServers;
+    }
+    const overrides = config.agents["codex-cli"].overrides;
+    const mergedConfig = isPlainObject(overrides) ? deepMerge(generatedConfig, overrides) : generatedConfig;
+    return serializeToml(mergedConfig);
+  }
+  buildMcpServers(config) {
+    const servers = {};
+    for (const [name, server] of Object.entries(config.mcp)) {
+      if (server.agents && !server.agents.includes("codex-cli")) continue;
+      if (isHttpMcp(server)) {
+        const entry = { url: server.url };
+        if (server.headers && Object.keys(server.headers).length > 0) {
+          entry.http_headers = server.headers;
+        }
+        if (server.env && Object.keys(server.env).length > 0) {
+          entry.env = server.env;
+        }
+        servers[name] = entry;
+      } else {
+        const entry = { command: server.command, args: server.args };
+        if (server.env && Object.keys(server.env).length > 0) {
+          entry.env = server.env;
+        }
+        servers[name] = entry;
+      }
+    }
+    return servers;
+  }
+  buildSkill(skill) {
+    const fm = { ...skill.frontmatter };
+    if (fm.model && typeof fm.model === "object" && !Array.isArray(fm.model)) {
+      const modelMap = fm.model;
+      if (modelMap["codex-cli"]) {
+        fm.model = modelMap["codex-cli"];
+      } else {
+        delete fm.model;
+      }
+    }
+    const frontmatterLines = this.serializeFrontmatter(fm);
+    return `---
+${frontmatterLines}
+---
+
+${skill.body}`;
+  }
+  serializeFrontmatter(fm) {
+    const lines = [];
+    for (const [key, value] of Object.entries(fm)) {
+      if (typeof value === "string") {
+        lines.push(`${key}: ${value}`);
+      } else if (typeof value === "boolean") {
+        lines.push(`${key}: ${value}`);
+      } else if (Array.isArray(value)) {
+        lines.push(`${key}: [${value.join(", ")}]`);
+      }
+    }
+    return lines.join("\n");
+  }
+};
+
+// src/generators/gemini-cli.ts
+var GeminiCliGenerator = class {
+  name = "gemini-cli";
+  generate(config, context) {
+    const files = [];
+    files.push({
+      path: "GEMINI.md",
+      content: this.buildInstructions(context)
+    });
+    files.push({
+      path: ".gemini/settings.json",
+      content: this.buildSettings(config)
+    });
+    for (const command of context.commands) {
+      files.push({
+        path: `.gemini/commands/meld/${command.name}.toml`,
+        content: this.buildCommandToml(command.name, command.content)
+      });
+    }
+    for (const skill of context.skills) {
+      files.push({
+        path: `.gemini/commands/meld/${skill.name}.toml`,
+        content: this.buildSkillToml(skill)
+      });
+    }
+    for (const file of context.contextFiles) {
+      files.push({ path: file.path, content: file.content });
+    }
+    return files;
+  }
+  buildInstructions(context) {
+    const sections = [context.hubPreamble];
+    if (context.projectTable) {
+      sections.push(context.projectTable);
+    }
+    sections.push(context.artifactsSection);
+    if (context.context) {
+      sections.push(context.context);
+    }
+    return sections.join("\n\n");
+  }
+  buildSettings(config) {
+    const servers = {};
+    for (const [name, server] of Object.entries(config.mcp)) {
+      if (server.agents && !server.agents.includes("gemini-cli")) continue;
+      if (isHttpMcp(server)) {
+        const entry = { type: "http", url: server.url };
+        if (server.headers) entry.headers = server.headers;
+        if (server.env) entry.env = server.env;
+        servers[name] = entry;
+      } else {
+        const entry = { command: server.command, args: server.args };
+        if (server.env) entry.env = server.env;
+        servers[name] = entry;
+      }
+    }
+    const settings = { mcpServers: servers };
+    const overrides = config.agents["gemini-cli"].overrides;
+    const mergedSettings = isPlainObject(overrides) ? deepMerge(settings, overrides) : settings;
+    return JSON.stringify(mergedSettings, null, 2);
+  }
+  buildCommandToml(name, content) {
+    return [
+      `description = "${name}"`,
+      "",
+      `[template]`,
+      `prompt = """`,
+      content,
+      `"""`
+    ].join("\n");
+  }
+  buildSkillToml(skill) {
+    const description = skill.frontmatter.description ?? skill.name;
+    return [
+      `# skill: ${skill.name}`,
+      `description = "${description}"`,
+      "",
+      `[template]`,
+      `prompt = """`,
+      skill.body,
+      `"""`
+    ].join("\n");
+  }
+};
+
+// src/generators/workspace.ts
+import { homedir } from "os";
+var WorkspaceGenerator = class {
+  name = "workspace";
+  generate(config, _context) {
+    const folders = [
+      { name: config.ide.workspaceName, path: "." },
+      ...Object.entries(config.projects).map(([name, project]) => ({
+        name,
+        path: resolveTilde(project.path)
+      }))
+    ];
+    const workspace = {
+      folders,
+      settings: {}
+    };
+    return [
+      {
+        path: `${config.ide.workspaceName}.code-workspace`,
+        content: JSON.stringify(workspace, null, 2)
+      }
+    ];
+  }
+};
+function resolveTilde(path) {
+  if (path.startsWith("~/")) {
+    return homedir() + path.slice(1);
+  }
+  return path;
+}
+
+// src/generators/gitignore.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+var START_MARKER = "# \u2500\u2500 meld managed (do not edit) \u2500\u2500";
+var END_MARKER = "# \u2500\u2500 end meld managed \u2500\u2500";
+var GitignoreGenerator = class {
+  name = "gitignore";
+  generate(_config, context) {
+    const lines = [
+      "agents/",
+      "scratch/"
+    ];
+    const managedBlock = [
+      START_MARKER,
+      ...lines,
+      END_MARKER
+    ].join("\n");
+    const content = spliceIntoExisting(context.hubDir, managedBlock);
+    return [{ path: ".gitignore", content }];
+  }
+};
+function spliceIntoExisting(hubDir, managedBlock) {
+  const gitignorePath = join4(hubDir, ".gitignore");
+  if (!existsSync3(gitignorePath)) {
+    return managedBlock + "\n";
+  }
+  const existing = readFileSync3(gitignorePath, "utf-8");
+  const startIdx = existing.indexOf(START_MARKER);
+  const endIdx = existing.indexOf(END_MARKER);
+  if (startIdx === -1 || endIdx === -1) {
+    const trimmed = existing.trimEnd();
+    return trimmed + (trimmed.length > 0 ? "\n\n" : "") + managedBlock + "\n";
+  }
+  const before = existing.slice(0, startIdx);
+  const after = existing.slice(endIdx + END_MARKER.length);
+  return before + managedBlock + after;
+}
+
+// src/generate.ts
+var AGENT_GENERATORS = {
+  "claude-code": () => new ClaudeCodeGenerator(),
+  "codex-cli": () => new CodexCliGenerator(),
+  "gemini-cli": () => new GeminiCliGenerator()
+};
+function generate(hubDir, options = {}) {
+  const loadResult = loadConfig(hubDir);
+  if (!loadResult.ok) {
+    return { ok: false, errors: loadResult.errors };
+  }
+  const { config, warnings } = interpolateEnv(loadResult.config);
+  const context = composeContext(hubDir, config);
+  const allFiles = [];
+  for (const [name, agentConfig] of Object.entries(config.agents)) {
+    if (!agentConfig.enabled) continue;
+    if (options.agent && options.agent !== name) continue;
+    const agentDir = resolveAgentDir(name, agentConfig);
+    const factory = AGENT_GENERATORS[name];
+    if (!factory) continue;
+    const files = factory().generate(config, context);
+    for (const file of files) {
+      file.path = `${AGENTS_DIR}/${agentDir}/${file.path}`;
+    }
+    allFiles.push(...files);
+  }
+  if (!options.agent) {
+    allFiles.push(...new WorkspaceGenerator().generate(config, context));
+    allFiles.push(...new GitignoreGenerator().generate(config, context));
+  }
+  if (!options.dryRun) {
+    for (const name of Object.keys(config.projects)) {
+      mkdirSync2(join5(hubDir, "artifacts", "projects", name), { recursive: true });
+    }
+  }
+  writeGeneratedFiles(hubDir, allFiles, { dryRun: options.dryRun });
+  return { ok: true, files: allFiles, warnings };
+}
+
+// src/cli/gen.ts
+var genCommand = new Command("gen").description("Generate all agent configs from meld.jsonc").option("--dry-run", "Preview changes without writing files").option("--agent <name>", "Generate for a single agent (claude-code, codex-cli, gemini-cli)").action((options) => {
+  const hubDir = process.cwd();
+  const result = generate(hubDir, {
+    dryRun: options.dryRun,
+    agent: options.agent
+  });
+  if (!result.ok) {
+    console.error("Generation failed:");
+    for (const error of result.errors) {
+      console.error(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+  if (result.warnings.length > 0) {
+    for (const w of result.warnings) {
+      console.warn(`  warning: ${w}`);
+    }
+    console.warn();
+  }
+  if (options.dryRun) {
+    console.log("Dry run \u2014 would generate:");
+  } else {
+    console.log("Generated:");
+  }
+  for (const file of result.files) {
+    console.log(`  ${file.path}`);
+  }
+  console.log(`
+${result.files.length} file(s) ${options.dryRun ? "would be" : ""} generated.`);
+});
+
+// src/cli/init.ts
+import { Command as Command2 } from "commander";
+import * as p from "@clack/prompts";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
+import { execSync } from "child_process";
+import { join as join7 } from "path";
+
+// src/hub-schema.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { fileURLToPath } from "url";
+function readPackageSchema() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  while (dir !== dirname2(dir)) {
+    const schemaPath = join6(dir, "meld.schema.json");
+    if (existsSync4(schemaPath)) {
+      return readFileSync4(schemaPath, "utf-8");
+    }
+    dir = dirname2(dir);
+  }
+  throw new Error("Could not locate meld.schema.json");
+}
+
+// src/readme.ts
+function generateReadme(config) {
+  const agentLabels = {
+    "claude-code": "Claude Code",
+    "codex-cli": "Codex CLI",
+    "gemini-cli": "Gemini CLI"
+  };
+  const agentCommands = {
+    "claude-code": "`meld claude`",
+    "codex-cli": "`meld codex`",
+    "gemini-cli": "`meld gemini`"
+  };
+  const enabledAgents = Object.entries(config.agents).filter(([, a]) => a.enabled).map(([name]) => name);
+  const enabled = enabledAgents.map((a) => agentLabels[a] ?? a).join(", ");
+  const launchCmds = enabledAgents.map((a) => agentCommands[a] ?? `\`meld ${a}\``).join(" / ");
+  return [
+    `# ${config.ide.workspaceName}`,
+    "",
+    `A multi-project workspace powered by [meld](https://github.com/vitld/meld-cli).`,
+    "",
+    `**Enabled agents:** ${enabled}`,
+    "",
+    "## Getting Started",
+    "",
+    "1. Add projects: `meld project add`",
+    "2. Add agent instructions in `context/` (markdown files)",
+    "3. Generate configs: `meld gen`",
+    `4. Launch an agent: ${launchCmds}`,
+    "",
+    "## Structure",
+    "",
+    "| Path | Purpose |",
+    "|------|---------|",
+    "| `meld.jsonc` | Central configuration |",
+    "| `context/` | Markdown instructions for agents |",
+    "| `commands/` | Slash commands |",
+    "| `skills/` | Reusable agent skills |",
+    "| `artifacts/` | Research, plans, and notes |",
+    "| `scratch/` | Temporary work (gitignored) |",
+    "| `agents/` | Generated output (gitignored) |",
+    "",
+    "## Context",
+    "",
+    "Files in the root of `context/` are inlined into agent instructions.",
+    "Subfolders are copied into each agent's working directory, so you can",
+    "link to them with relative paths like `./subfolder/doc.md`.",
+    "",
+    "```",
+    "context/",
+    "  01-role.md          # Inlined into CLAUDE.md / AGENTS.md / GEMINI.md",
+    "  02-guardrails.md    # Inlined (alphabetical order)",
+    "  reference/          # Copied as agents/<name>/reference/",
+    "    api.md",
+    "    patterns.md",
+    "```",
+    "",
+    "The filename determines order \u2014 use numeric prefixes to control sequencing.",
+    "After editing, run `meld gen` to regenerate agent configs.",
+    "",
+    "## MCP Servers",
+    "",
+    "MCP servers are defined once in `meld.jsonc` under the `mcp` key and automatically",
+    "translated into each agent's native config format (`.mcp.json`, `.codex/config.toml`,",
+    "`.gemini/settings.json`).",
+    "",
+    "### Stdio server (local process)",
+    "",
+    "Runs a command as a child process, communicating over stdin/stdout.",
+    "",
+    "```jsonc",
+    '"my-server": {',
+    '  "command": "npx",',
+    '  "args": ["-y", "my-mcp-server@latest"],',
+    '  "env": {               // optional',
+    '    "API_KEY": "sk-..."',
+    "  }",
+    "}",
+    "```",
+    "",
+    "### HTTP server (remote)",
+    "",
+    "Connects to a remote MCP endpoint over HTTP.",
+    "",
+    "```jsonc",
+    '"my-server": {',
+    '  "type": "http",',
+    '  "url": "https://mcp.example.com/mcp",',
+    '  "headers": {            // optional',
+    '    "Authorization": "Bearer tok-..."',
+    "  }",
+    "}",
+    "```",
+    "",
+    "### Scoping servers to specific agents",
+    "",
+    "By default every MCP server is available to all enabled agents.",
+    "Use `agents` to restrict a server to specific agents:",
+    "",
+    "```jsonc",
+    '"my-server": {',
+    '  "command": "node",',
+    '  "args": ["server.js"],',
+    '  "agents": ["claude-code"]  // only generated for Claude Code',
+    "}",
+    "```",
+    "",
+    "Valid agent names: `claude-code`, `codex-cli`, `gemini-cli`.",
+    "",
+    "## Commands",
+    "",
+    "| Command | Description |",
+    "|---------|-------------|",
+    "| `meld gen` | Generate agent configs from `meld.jsonc` |",
+    "| `meld gen --dry-run` | Preview without writing files |",
+    "| `meld project add` | Register a project |",
+    "| `meld project list` | List registered projects |",
+    "| `meld open` | Open workspace in IDE |",
+    "| `meld update` | Re-scaffold hub structure |",
+    "",
+    "> Edit `meld.jsonc` for configuration. Run `meld gen` after changes.",
+    ""
+  ].join("\n");
+}
+
+// src/cli/init.ts
+function ensureDir(path) {
+  mkdirSync3(path, { recursive: true });
+}
+var initCommand = new Command2("init").description("Initialize a new meld hub").action(async () => {
+  p.intro("meld \u2014 agent config generator");
+  const hubDir = process.cwd();
+  if (existsSync5(join7(hubDir, "meld.jsonc"))) {
+    p.log.warn("meld.jsonc already exists in this directory.");
+    const overwrite = await p.confirm({
+      message: "Overwrite existing config?",
+      initialValue: false
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  const ignored = /* @__PURE__ */ new Set([".git", "meld.jsonc"]);
+  const existing = readdirSync2(hubDir).filter((f) => !ignored.has(f));
+  if (existing.length > 0) {
+    p.log.warn(
+      `Directory contains ${existing.length} existing file(s): ${existing.slice(0, 5).join(", ")}${existing.length > 5 ? ", ..." : ""}`
+    );
+    const proceed = await p.confirm({
+      message: "This directory contains existing files. Running init here will commit them all. Continue?",
+      initialValue: false
+    });
+    if (p.isCancel(proceed) || !proceed) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+  }
+  const agents = await p.multiselect({
+    message: "Which agents do you want to generate configs for?",
+    options: [
+      { value: "claude-code", label: "Claude Code" },
+      { value: "codex-cli", label: "Codex CLI" },
+      { value: "gemini-cli", label: "Gemini CLI" }
+    ],
+    required: true
+  });
+  if (p.isCancel(agents)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const ide = await p.select({
+    message: "Default IDE?",
+    options: [
+      { value: "cursor", label: "Cursor" },
+      { value: "code", label: "VS Code" },
+      { value: "windsurf", label: "Windsurf" }
+    ]
+  });
+  if (p.isCancel(ide)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const workspaceName = await p.text({
+    message: "Workspace name",
+    placeholder: "meld-hub",
+    defaultValue: "meld-hub"
+  });
+  if (p.isCancel(workspaceName)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  const config = {
+    projects: {},
+    agents: {
+      "claude-code": { enabled: agents.includes("claude-code") },
+      "codex-cli": { enabled: agents.includes("codex-cli") },
+      "gemini-cli": { enabled: agents.includes("gemini-cli") }
+    },
+    mcp: {},
+    ide: {
+      default: ide,
+      workspaceName
+    }
+  };
+  const configWithSchema = { $schema: "./meld.schema.json", ...config };
+  writeFileSync2(join7(hubDir, "meld.jsonc"), JSON.stringify(configWithSchema, null, 2));
+  writeFileSync2(join7(hubDir, "meld.schema.json"), readPackageSchema());
+  writeFileSync2(join7(hubDir, "README.md"), generateReadme(config));
+  ensureDir(join7(hubDir, "context"));
+  ensureDir(join7(hubDir, "commands"));
+  ensureDir(join7(hubDir, "skills"));
+  ensureDir(join7(hubDir, "artifacts", "hub"));
+  ensureDir(join7(hubDir, "scratch"));
+  writeFileSync2(join7(hubDir, ".gitignore"), [
+    "# \u2500\u2500 meld managed (do not edit) \u2500\u2500",
+    "agents/",
+    "scratch/",
+    "# \u2500\u2500 end meld managed \u2500\u2500"
+  ].join("\n") + "\n");
+  const hasGit = existsSync5(join7(hubDir, ".git"));
+  if (!hasGit) {
+    execSync("git init", { cwd: hubDir, stdio: "ignore" });
+  }
+  const meldFiles = [
+    "meld.jsonc",
+    "meld.schema.json",
+    "README.md",
+    ".gitignore"
+  ];
+  execSync(`git add ${meldFiles.join(" ")}`, { cwd: hubDir, stdio: "ignore" });
+  execSync('git commit -m "init meld hub"', { cwd: hubDir, stdio: "ignore" });
+  p.outro(
+    [
+      "Done! Created:",
+      `  meld.jsonc          \u2014 central config (with schema for IDE autocomplete)`,
+      `  meld.schema.json    \u2014 JSON schema for validation`,
+      `  README.md           \u2014 getting started guide`,
+      `  context/            \u2014 agent instructions`,
+      `  commands/            \u2014 slash commands`,
+      `  skills/              \u2014 reusable skills`,
+      `  artifacts/hub/       \u2014 research & notes`,
+      `  scratch/             \u2014 temporary work`,
+      "",
+      "Next: add projects with `meld project add`, edit context/, then run `meld gen`"
+    ].join("\n")
+  );
+});
+
+// src/cli/project.ts
+import { Command as Command3 } from "commander";
+import * as p2 from "@clack/prompts";
+import { mkdirSync as mkdirSync4 } from "fs";
+import { join as join9 } from "path";
+
+// src/config/writer.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { join as join8 } from "path";
+import { parse as parseJsonc2 } from "jsonc-parser";
+function updateConfig(hubDir, updater) {
+  const configPath = join8(hubDir, "meld.jsonc");
+  const raw = readFileSync5(configPath, "utf-8");
+  const config = parseJsonc2(raw);
+  updater(config);
+  writeFileSync3(configPath, JSON.stringify(config, null, 2));
+}
+
+// src/cli/project.ts
+var projectCommand = new Command3("project").description("Manage projects");
+projectCommand.command("add").description("Add a project interactively").action(async () => {
+  const hubDir = process.cwd();
+  const name = await p2.text({
+    message: "Project name (used as config key)",
+    placeholder: "my-project"
+  });
+  if (p2.isCancel(name)) return;
+  const path = await p2.text({
+    message: "Path to project",
+    placeholder: "~/projects/my-project"
+  });
+  if (p2.isCancel(path)) return;
+  const aliasesRaw = await p2.text({
+    message: "Aliases (comma-separated, how you refer to it)",
+    placeholder: "my proj, the project",
+    defaultValue: ""
+  });
+  if (p2.isCancel(aliasesRaw)) return;
+  const aliases = aliasesRaw.split(",").map((a) => a.trim()).filter(Boolean);
+  const repo = await p2.text({
+    message: "GitHub repo (org/repo, optional)",
+    placeholder: "org/repo",
+    defaultValue: ""
+  });
+  if (p2.isCancel(repo)) return;
+  updateConfig(hubDir, (config) => {
+    const projects = config.projects ?? {};
+    const entry = {
+      path,
+      aliases
+    };
+    if (repo) entry.repo = repo;
+    projects[name] = entry;
+    config.projects = projects;
+  });
+  mkdirSync4(join9(hubDir, "artifacts", "projects", name), { recursive: true });
+  generate(hubDir);
+  console.log(`Added project "${name}" and regenerated configs.`);
+});
+projectCommand.command("list").description("List registered projects").action(() => {
+  const hubDir = process.cwd();
+  const result = loadConfig(hubDir);
+  if (!result.ok) {
+    console.error("Failed to load config:", result.errors.join(", "));
+    process.exit(1);
+  }
+  const projects = Object.entries(result.config.projects);
+  if (projects.length === 0) {
+    console.log("No projects registered. Run: meld project add");
+    return;
+  }
+  console.log("Projects:\n");
+  for (const [name, project] of projects) {
+    console.log(`  ${name}`);
+    console.log(`    Path: ${project.path}`);
+    if (project.aliases.length > 0) {
+      console.log(`    Aliases: ${project.aliases.join(", ")}`);
+    }
+    if (project.repo) {
+      console.log(`    Repo: ${project.repo}`);
+    }
+    console.log("");
+  }
+});
+projectCommand.command("remove <name>").description("Remove a project").action((name) => {
+  const hubDir = process.cwd();
+  updateConfig(hubDir, (config) => {
+    const projects = config.projects;
+    if (!(name in projects)) {
+      console.error(`Project "${name}" not found.`);
+      process.exit(1);
+    }
+    delete projects[name];
+  });
+  generate(hubDir);
+  console.log(`Removed project "${name}" and regenerated configs.`);
+});
+
+// src/cli/open.ts
+import { Command as Command4 } from "commander";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { join as join10 } from "path";
+var IDE_COMMANDS = {
+  cursor: "cursor",
+  code: "code",
+  windsurf: "windsurf"
+};
+var openCommand = new Command4("open").description("Open the hub workspace in your IDE").option("--ide <name>", "IDE to use (cursor, code, windsurf)").action((options) => {
+  const hubDir = process.cwd();
+  const result = loadConfig(hubDir);
+  if (!result.ok) {
+    console.error("Failed to load config:", result.errors.join(", "));
+    process.exit(1);
+  }
+  const ide = options.ide ?? result.config.ide.default;
+  const command = IDE_COMMANDS[ide];
+  if (!command) {
+    console.error(`Unknown IDE: ${ide}. Supported: ${Object.keys(IDE_COMMANDS).join(", ")}`);
+    process.exit(1);
+  }
+  const workspaceFile = join10(
+    hubDir,
+    `${result.config.ide.workspaceName}.code-workspace`
+  );
+  if (!existsSync6(workspaceFile)) {
+    console.error(`Workspace file not found: ${workspaceFile}
+Run: meld gen`);
+    process.exit(1);
+  }
+  execSync2(`${command} "${workspaceFile}"`, { stdio: "inherit" });
+});
+
+// src/cli/update.ts
+import { Command as Command5 } from "commander";
+import * as p3 from "@clack/prompts";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
+import { join as join11 } from "path";
+function ensureDir2(path) {
+  mkdirSync5(path, { recursive: true });
+}
+function ensureSchema(hubDir) {
+  const configPath = join11(hubDir, "meld.jsonc");
+  const raw = readFileSync6(configPath, "utf-8");
+  if (raw.includes('"$schema"')) return;
+  const patched = raw.replace(/^\s*\{/, '{\n  "$schema": "./meld.schema.json",');
+  writeFileSync4(configPath, patched);
+}
+var updateCommand = new Command5("update").description("Re-scaffold hub structure and update defaults without touching config").action(() => {
+  const hubDir = process.cwd();
+  const loadResult = loadConfig(hubDir);
+  if (!loadResult.ok) {
+    p3.log.error(
+      `Cannot update: ${loadResult.errors.join(", ")}
+Run \`meld init\` first.`
+    );
+    process.exit(1);
+  }
+  const config = loadResult.config;
+  const standardDirs = [
+    "context",
+    "commands",
+    "skills",
+    join11("artifacts", "hub"),
+    "scratch"
+  ];
+  for (const dir of standardDirs) {
+    ensureDir2(join11(hubDir, dir));
+  }
+  for (const name of Object.keys(config.projects)) {
+    ensureDir2(join11(hubDir, "artifacts", "projects", name));
+  }
+  ensureSchema(hubDir);
+  writeFileSync4(join11(hubDir, "meld.schema.json"), readPackageSchema());
+  writeFileSync4(join11(hubDir, "README.md"), generateReadme(config));
+  const result = generate(hubDir);
+  if (!result.ok) {
+    p3.log.error(`Generation failed: ${result.errors.join(", ")}`);
+    process.exit(1);
+  }
+  p3.log.success("Updated hub structure and defaults.");
+  if (result.files.length > 0) {
+    p3.log.info("Generated files:");
+    for (const file of result.files) {
+      p3.log.message(`  ${file.path}`);
+    }
+  }
+  p3.log.info("Review changes, then commit when ready.");
+});
+
+// src/cli/run.ts
+import { Command as Command6 } from "commander";
+import { spawnSync } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { join as join12 } from "path";
+var AGENT_COMMANDS = {
+  "claude-code": "claude",
+  "codex-cli": "codex",
+  "gemini-cli": "gemini"
+};
+function runAgent(agentName, args) {
+  const hubDir = process.cwd();
+  const result = loadConfig(hubDir);
+  if (!result.ok) {
+    console.error("Failed to load config:", result.errors.join(", "));
+    process.exit(1);
+  }
+  const agentConfig = result.config.agents[agentName];
+  if (!agentConfig?.enabled) {
+    console.error(`Agent "${agentName}" is not enabled in meld.jsonc`);
+    process.exit(1);
+  }
+  const agentDir = join12(hubDir, AGENTS_DIR, resolveAgentDir(agentName, agentConfig));
+  if (!existsSync7(agentDir)) {
+    console.error(`Agent directory not found: ${agentDir}
+Run: meld gen`);
+    process.exit(1);
+  }
+  const command = AGENT_COMMANDS[agentName];
+  const { status, signal } = spawnSync(command, args, { cwd: agentDir, stdio: "inherit" });
+  if (signal) {
+    process.kill(process.pid, signal);
+  }
+  if (status !== null && status !== 0) {
+    process.exit(status);
+  }
+}
+function createAgentCommands() {
+  return Object.keys(AGENT_COMMANDS).map((agent) => {
+    return new Command6(agent).description(`Start ${agent} in its agent directory`).allowUnknownOption().allowExcessArguments().action((_options, cmd) => {
+      runAgent(agent, cmd.args);
+    });
+  });
+}
+
+// src/cli/index.ts
+function createCli() {
+  const program = new Command7("meld").description("Agent-agnostic settings generator").version("0.1.0");
+  program.addCommand(initCommand);
+  program.addCommand(genCommand);
+  program.addCommand(projectCommand);
+  program.addCommand(openCommand);
+  program.addCommand(updateCommand);
+  for (const cmd of createAgentCommands()) {
+    program.addCommand(cmd);
+  }
+  return program;
+}
+
+// src/index.ts
+createCli().parse();
+//# sourceMappingURL=index.js.map