kodelyth-ecc 1.5.9 → 1.7.0

package/scripts/mcp/catalog.js

@@ -0,0 +1,244 @@
+// =============================================================================
+// Kodelyth ECC — MCP Catalog
+// Read-only loader for agents, skills, commands, and rule files.
+// Pure file reads. Zero side effects. Cached after first call.
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..', '..');
+
+const PATHS = {
+  agents:   path.join(ROOT, 'agents'),
+  skills:   path.join(ROOT, 'skills'),
+  commands: path.join(ROOT, 'commands'),
+  rules:    path.join(ROOT, 'rules', 'common'),
+  bundles:  path.join(ROOT, 'bundles'),
+};
+
+// ── Frontmatter parser ───────────────────────────────────────────────────────
+// Minimal YAML frontmatter parser (key: value, supports basic > folded scalars).
+// We don't need full YAML — agent/skill files use a tiny subset.
+function parseFrontmatter(raw) {
+  if (typeof raw !== 'string') return { meta: {}, body: '' };
+  if (!raw.startsWith('---')) return { meta: {}, body: raw };
+
+  const end = raw.indexOf('\n---', 3);
+  if (end === -1) return { meta: {}, body: raw };
+
+  const fmText = raw.slice(3, end).replace(/^\r?\n/, '');
+  const body   = raw.slice(end + 4).replace(/^\r?\n/, '');
+
+  const meta = {};
+  const lines = fmText.split(/\r?\n/);
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim() || line.trim().startsWith('#')) { i++; continue; }
+    const m = /^([A-Za-z0-9_\-]+)\s*:\s*(.*)$/.exec(line);
+    if (!m) { i++; continue; }
+    const key = m[1];
+    let val = m[2].trim();
+    // Folded scalar: `>` or `>-`
+    if (val === '>' || val === '>-' || val === '|' || val === '|-') {
+      const folded = [];
+      let j = i + 1;
+      const baseIndent = (lines[j] || '').match(/^(\s*)/)[1].length;
+      while (j < lines.length) {
+        const next = lines[j];
+        if (next.trim() && (next.match(/^(\s*)/)[1].length < baseIndent)) break;
+        folded.push(next.slice(baseIndent));
+        j++;
+      }
+      meta[key] = folded.join(val.startsWith('>') ? ' ' : '\n').trim();
+      i = j;
+      continue;
+    }
+    // Quoted strings
+    if ((val.startsWith('"') && val.endsWith('"')) ||
+        (val.startsWith("'") && val.endsWith("'"))) {
+      val = val.slice(1, -1);
+    }
+    meta[key] = val;
+    i++;
+  }
+  return { meta, body };
+}
+
+// ── Generic directory loader ─────────────────────────────────────────────────
+function safeReadFile(p) {
+  try { return fs.readFileSync(p, 'utf8'); }
+  catch { return null; }
+}
+
+function listMarkdownFiles(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith('.md'))
+    .map(f => path.join(dir, f));
+}
+
+// ── Agents ───────────────────────────────────────────────────────────────────
+let _agentsCache = null;
+function loadAgents() {
+  if (_agentsCache) return _agentsCache;
+  const out = [];
+  for (const file of listMarkdownFiles(PATHS.agents)) {
+    const raw = safeReadFile(file);
+    if (raw === null) continue;
+    const { meta, body } = parseFrontmatter(raw);
+    const name = meta.name || path.basename(file, '.md');
+    out.push({
+      name,
+      description: meta.description || '',
+      file,
+      relpath: path.relative(ROOT, file),
+      meta,
+      body,
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  _agentsCache = out;
+  return out;
+}
+
+// ── Skills ───────────────────────────────────────────────────────────────────
+let _skillsCache = null;
+function loadSkills() {
+  if (_skillsCache) return _skillsCache;
+  const out = [];
+  if (!fs.existsSync(PATHS.skills)) { _skillsCache = out; return out; }
+  for (const dir of fs.readdirSync(PATHS.skills)) {
+    const skillFile = path.join(PATHS.skills, dir, 'SKILL.md');
+    const raw = safeReadFile(skillFile);
+    if (raw === null) continue;
+    const { meta, body } = parseFrontmatter(raw);
+    out.push({
+      name: meta.name || dir,
+      description: meta.description || '',
+      origin: meta.origin || '',
+      file: skillFile,
+      relpath: path.relative(ROOT, skillFile),
+      meta,
+      body,
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  _skillsCache = out;
+  return out;
+}
+
+// ── Commands ─────────────────────────────────────────────────────────────────
+let _commandsCache = null;
+function loadCommands() {
+  if (_commandsCache) return _commandsCache;
+  const out = [];
+  for (const file of listMarkdownFiles(PATHS.commands)) {
+    const raw = safeReadFile(file);
+    if (raw === null) continue;
+    const { meta, body } = parseFrontmatter(raw);
+    const name = meta.name || path.basename(file, '.md');
+    out.push({
+      name,
+      description: meta.description || '',
+      argumentHint: meta['argument-hint'] || '',
+      file,
+      relpath: path.relative(ROOT, file),
+      meta,
+      body,
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  _commandsCache = out;
+  return out;
+}
+
+// ── Rules ────────────────────────────────────────────────────────────────────
+function loadRule(name) {
+  const file = path.join(PATHS.rules, `${name}.md`);
+  const raw = safeReadFile(file);
+  if (raw === null) return null;
+  return { name, file, relpath: path.relative(ROOT, file), body: raw };
+}
+
+function loadAllRules() {
+  if (!fs.existsSync(PATHS.rules)) return [];
+  return listMarkdownFiles(PATHS.rules).map(file => {
+    const name = path.basename(file, '.md');
+    return {
+      name,
+      file,
+      relpath: path.relative(ROOT, file),
+      body: safeReadFile(file) || '',
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// ── Bundles ──────────────────────────────────────────────────────────────────
+function loadBundles() {
+  const out = [];
+  if (!fs.existsSync(PATHS.bundles)) return out;
+  for (const file of listMarkdownFiles(PATHS.bundles)) {
+    const raw = safeReadFile(file);
+    if (raw === null) continue;
+    const name = path.basename(file, '.md');
+    out.push({
+      name,
+      file,
+      relpath: path.relative(ROOT, file),
+      body: raw,
+    });
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// ── Lookups ──────────────────────────────────────────────────────────────────
+function findAgent(name) {
+  return loadAgents().find(a => a.name === name) || null;
+}
+function findSkill(name) {
+  return loadSkills().find(s => s.name === name) || null;
+}
+function findCommand(name) {
+  const target = String(name || '').replace(/^\//, '');
+  return loadCommands().find(c => c.name === target) || null;
+}
+
+// ── Stats ────────────────────────────────────────────────────────────────────
+function stats() {
+  return {
+    agents: loadAgents().length,
+    skills: loadSkills().length,
+    commands: loadCommands().length,
+    rules: loadAllRules().length,
+    bundles: loadBundles().length,
+    root: ROOT,
+  };
+}
+
+// ── Cache reset (mainly for tests) ───────────────────────────────────────────
+function resetCache() {
+  _agentsCache = null;
+  _skillsCache = null;
+  _commandsCache = null;
+}
+
+module.exports = {
+  PATHS,
+  ROOT,
+  parseFrontmatter,
+  loadAgents,
+  loadSkills,
+  loadCommands,
+  loadRule,
+  loadAllRules,
+  loadBundles,
+  findAgent,
+  findSkill,
+  findCommand,
+  stats,
+  resetCache,
+};

package/scripts/mcp/client.js

@@ -0,0 +1,181 @@
+// =============================================================================
+// Kodelyth ECC — MCP Client (registry + connect helpers)
+//
+// Lets ECC consume external MCP servers (Stripe, GitHub, Postgres, Brave,
+// Redis, Filesystem, etc.). Pairs with scripts/mcp/server.js — together they
+// make ECC the MCP HUB: serve to any framework, consume from any provider.
+//
+// Storage:
+//   ~/.kodelyth/mcp-clients.json     registry of named external servers
+//
+// Public API (all functions pure or local file-only):
+//   loadRegistry(), saveRegistry(reg)
+//   addServer({ name, command, args, env })
+//   removeServer(name)
+//   listServers()
+//   getServer(name)
+//
+// Connection helpers (require @modelcontextprotocol/sdk):
+//   connect(name)               -> { client, transport, close }
+//   listTools(name)
+//   callTool(name, tool, args)
+//   listResources(name)
+//   readResource(name, uri)
+//   listPrompts(name)
+//   getPrompt(name, prompt, args)
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+
+const REGISTRY_DIR = process.env.KODELYTH_MCP_CLIENT_DIR
+  || path.join(os.homedir(), '.kodelyth');
+const REGISTRY_FILE = path.join(REGISTRY_DIR, 'mcp-clients.json');
+
+// ── Registry I/O ─────────────────────────────────────────────────────────────
+function ensureDir(d) {
+  try { if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true }); } catch {}
+}
+
+function loadRegistry() {
+  try {
+    if (!fs.existsSync(REGISTRY_FILE)) return { servers: {} };
+    const raw = fs.readFileSync(REGISTRY_FILE, 'utf8');
+    const obj = JSON.parse(raw);
+    if (!obj || typeof obj !== 'object' || !obj.servers) return { servers: {} };
+    return obj;
+  } catch {
+    return { servers: {} };
+  }
+}
+
+function saveRegistry(reg) {
+  ensureDir(REGISTRY_DIR);
+  fs.writeFileSync(REGISTRY_FILE, JSON.stringify(reg, null, 2) + '\n');
+}
+
+// ── Registry mutations ───────────────────────────────────────────────────────
+function addServer({ name, command, args = [], env = {}, description = '' }) {
+  if (!name || typeof name !== 'string') throw new Error('addServer: `name` is required');
+  if (!/^[a-z0-9][a-z0-9_\-]*$/i.test(name)) {
+    throw new Error('addServer: name must be alphanumeric / dash / underscore (e.g. "redis", "github-mcp")');
+  }
+  if (!command || typeof command !== 'string') throw new Error('addServer: `command` is required');
+  const reg = loadRegistry();
+  reg.servers[name] = {
+    name,
+    command,
+    args:        Array.isArray(args) ? args.map(String) : [],
+    env:         (env && typeof env === 'object') ? env : {},
+    description: String(description || ''),
+    added_at:    new Date().toISOString(),
+  };
+  saveRegistry(reg);
+  return reg.servers[name];
+}
+
+function removeServer(name) {
+  const reg = loadRegistry();
+  if (!reg.servers[name]) return false;
+  delete reg.servers[name];
+  saveRegistry(reg);
+  return true;
+}
+
+function listServers() {
+  const reg = loadRegistry();
+  return Object.values(reg.servers).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function getServer(name) {
+  const reg = loadRegistry();
+  return reg.servers[name] || null;
+}
+
+// ── SDK lazy load ────────────────────────────────────────────────────────────
+function loadSdk() {
+  try {
+    return {
+      Client: require('@modelcontextprotocol/sdk/client/index.js').Client,
+      StdioClientTransport: require('@modelcontextprotocol/sdk/client/stdio.js').StdioClientTransport,
+    };
+  } catch (e) {
+    const err = new Error(
+      'Kodelyth MCP client requires `@modelcontextprotocol/sdk`. ' +
+      'Install with `npm install @modelcontextprotocol/sdk` or run via `npx -y kodelyth-ecc ...`. ' +
+      `Underlying error: ${e.message}`
+    );
+    err.code = 'MCP_SDK_MISSING';
+    throw err;
+  }
+}
+
+// ── Connection helper ────────────────────────────────────────────────────────
+async function connect(name) {
+  const spec = getServer(name);
+  if (!spec) {
+    const err = new Error(`MCP server "${name}" is not registered. Use \`kodelyth-ecc mcp-add\` first.`);
+    err.code = 'MCP_SERVER_NOT_REGISTERED';
+    throw err;
+  }
+  const { Client, StdioClientTransport } = loadSdk();
+
+  const transport = new StdioClientTransport({
+    command: spec.command,
+    args:    spec.args,
+    env:     { ...process.env, ...spec.env },
+  });
+  const client = new Client(
+    { name: 'kodelyth-ecc-client', version: '1.7.0' },
+    { capabilities: {} }
+  );
+  await client.connect(transport);
+  const close = async () => {
+    try { await client.close(); } catch {}
+  };
+  return { client, transport, close, spec };
+}
+
+// ── Convenience wrappers ─────────────────────────────────────────────────────
+async function withClient(name, fn) {
+  const session = await connect(name);
+  try {
+    return await fn(session.client);
+  } finally {
+    await session.close();
+  }
+}
+
+async function listTools(name)  { return withClient(name, c => c.listTools()); }
+async function callTool(name, tool, args = {}) {
+  return withClient(name, c => c.callTool({ name: tool, arguments: args }));
+}
+async function listResources(name) { return withClient(name, c => c.listResources()); }
+async function readResource(name, uri) {
+  return withClient(name, c => c.readResource({ uri }));
+}
+async function listPrompts(name) { return withClient(name, c => c.listPrompts()); }
+async function getPrompt(name, promptName, args = {}) {
+  return withClient(name, c => c.getPrompt({ name: promptName, arguments: args }));
+}
+
+module.exports = {
+  REGISTRY_FILE,
+  loadRegistry,
+  saveRegistry,
+  addServer,
+  removeServer,
+  listServers,
+  getServer,
+  connect,
+  withClient,
+  listTools,
+  callTool,
+  listResources,
+  readResource,
+  listPrompts,
+  getPrompt,
+};

package/scripts/mcp/prompts.js

@@ -0,0 +1,133 @@
+// =============================================================================
+// Kodelyth ECC — MCP Prompts
+// Exposes ECC's intent routing rule, handoff chains, and parallel commands
+// as MCP prompts that any compatible client can summon by name.
+// =============================================================================
+
+'use strict';
+
+const catalog = require('./catalog');
+
+// Each prompt definition:
+//   { name, description, arguments?: [{ name, description, required }] }
+const PROMPT_DEFINITIONS = [
+  {
+    name: 'routing-rule',
+    description: 'The full ECC intent routing rule — 10-tier priority system mapping user intent to specialist agents.',
+    arguments: [],
+    handler: () => {
+      const r = catalog.loadRule('agent-intent-routing');
+      if (!r) throw new Error('Routing rule not found.');
+      return {
+        description: 'ECC intent routing rule',
+        messages: [{
+          role: 'user',
+          content: { type: 'text', text: r.body },
+        }],
+      };
+    },
+  },
+  {
+    name: 'agents-overview',
+    description: 'A compact overview of every ECC agent (name + one-line description). Useful for orientation.',
+    arguments: [],
+    handler: () => {
+      const lines = catalog.loadAgents().map(a =>
+        `- **${a.name}** — ${a.description.replace(/\s+/g, ' ').trim().slice(0, 200)}`
+      );
+      return {
+        description: 'ECC agents overview',
+        messages: [{
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `# Kodelyth ECC — Agents (${lines.length})\n\n${lines.join('\n')}\n`,
+          },
+        }],
+      };
+    },
+  },
+  {
+    name: 'skills-overview',
+    description: 'A compact overview of every ECC skill (name + one-line description).',
+    arguments: [],
+    handler: () => {
+      const lines = catalog.loadSkills().map(s =>
+        `- **${s.name}** — ${s.description.replace(/\s+/g, ' ').trim().slice(0, 200)}`
+      );
+      return {
+        description: 'ECC skills overview',
+        messages: [{
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `# Kodelyth ECC — Skills (${lines.length})\n\n${lines.join('\n')}\n`,
+          },
+        }],
+      };
+    },
+  },
+  {
+    name: 'commands-overview',
+    description: 'A compact overview of every ECC slash command.',
+    arguments: [],
+    handler: () => {
+      const lines = catalog.loadCommands().map(c => {
+        const hint = c.argumentHint ? ` _(args: ${c.argumentHint})_` : '';
+        return `- **/${c.name}**${hint} — ${c.description.replace(/\s+/g, ' ').trim().slice(0, 200)}`;
+      });
+      return {
+        description: 'ECC commands overview',
+        messages: [{
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `# Kodelyth ECC — Commands (${lines.length})\n\n${lines.join('\n')}\n`,
+          },
+        }],
+      };
+    },
+  },
+  {
+    name: 'handoff-chains',
+    description: 'Standard ECC multi-agent handoff chains for common workflows (new feature, bug fix, refactor, incident, etc.).',
+    arguments: [],
+    handler: () => {
+      const skill = catalog.findSkill('agent-handoff');
+      const text = skill
+        ? `# Skill: agent-handoff\n\n${skill.description}\n\n---\n\n${skill.body}`
+        : '# Handoff chains\n\n(agent-handoff skill not found — fall back to README)';
+      return {
+        description: 'ECC handoff chains',
+        messages: [{
+          role: 'user',
+          content: { type: 'text', text },
+        }],
+      };
+    },
+  },
+  {
+    name: 'devil-mode',
+    description: 'The /devil-mode adversarial parallel command — fires the red-team crew at a target.',
+    arguments: [],
+    handler: () => {
+      const cmd = catalog.findCommand('devil-mode');
+      const text = cmd
+        ? `# Command: /devil-mode\n\n${cmd.description}\n\n---\n\n${cmd.body}`
+        : '# /devil-mode\n\n(devil-mode command not found)';
+      return {
+        description: 'ECC /devil-mode parallel command',
+        messages: [{
+          role: 'user',
+          content: { type: 'text', text },
+        }],
+      };
+    },
+  },
+];
+
+const PROMPT_HANDLERS = Object.fromEntries(
+  PROMPT_DEFINITIONS.map(p => [p.name, p.handler])
+);
+
+module.exports = { PROMPT_DEFINITIONS, PROMPT_HANDLERS };

package/scripts/mcp/resources.js

@@ -0,0 +1,94 @@
+// =============================================================================
+// Kodelyth ECC — MCP Resources
+// Exposes every agent, skill, command, rule, and bundle as an MCP resource.
+// URI scheme:
+//   kodelyth://agents/<name>
+//   kodelyth://skills/<name>
+//   kodelyth://commands/<name>
+//   kodelyth://rules/<name>
+//   kodelyth://bundles/<name>
+// =============================================================================
+
+'use strict';
+
+const catalog = require('./catalog');
+
+const SCHEME = 'kodelyth';
+
+function buildList() {
+  const out = [];
+
+  for (const a of catalog.loadAgents()) {
+    out.push({
+      uri: `${SCHEME}://agents/${a.name}`,
+      name: `Agent: ${a.name}`,
+      description: a.description,
+      mimeType: 'text/markdown',
+    });
+  }
+  for (const s of catalog.loadSkills()) {
+    out.push({
+      uri: `${SCHEME}://skills/${s.name}`,
+      name: `Skill: ${s.name}`,
+      description: s.description,
+      mimeType: 'text/markdown',
+    });
+  }
+  for (const c of catalog.loadCommands()) {
+    out.push({
+      uri: `${SCHEME}://commands/${c.name}`,
+      name: `Command: /${c.name}`,
+      description: c.description,
+      mimeType: 'text/markdown',
+    });
+  }
+  for (const r of catalog.loadAllRules()) {
+    out.push({
+      uri: `${SCHEME}://rules/${r.name}`,
+      name: `Rule: ${r.name}`,
+      description: `ECC rule file (${r.relpath})`,
+      mimeType: 'text/markdown',
+    });
+  }
+  for (const b of catalog.loadBundles()) {
+    out.push({
+      uri: `${SCHEME}://bundles/${b.name}`,
+      name: `Bundle: ${b.name}`,
+      description: `Power bundle cheat sheet (${b.relpath})`,
+      mimeType: 'text/markdown',
+    });
+  }
+  return out;
+}
+
+function readResource(uri) {
+  const m = /^kodelyth:\/\/(agents|skills|commands|rules|bundles)\/([^/]+)$/.exec(uri || '');
+  if (!m) {
+    throw new Error(`Unknown resource URI: ${uri}`);
+  }
+  const kind = m[1];
+  const name = decodeURIComponent(m[2]);
+
+  let body = null;
+  if (kind === 'agents')   { const a = catalog.findAgent(name);   if (a) body = `# Agent: ${a.name}\n\n${a.description}\n\n---\n\n${a.body}`; }
+  if (kind === 'skills')   { const s = catalog.findSkill(name);   if (s) body = `# Skill: ${s.name}\n\n${s.description}\n\n---\n\n${s.body}`; }
+  if (kind === 'commands') { const c = catalog.findCommand(name); if (c) body = `# Command: /${c.name}\n\n${c.description}\n\n---\n\n${c.body}`; }
+  if (kind === 'rules')    { const r = catalog.loadRule(name);    if (r) body = r.body; }
+  if (kind === 'bundles')  {
+    const b = catalog.loadBundles().find(x => x.name === name);
+    if (b) body = b.body;
+  }
+
+  if (body === null) {
+    throw new Error(`Resource not found: ${uri}`);
+  }
+  return {
+    contents: [{
+      uri,
+      mimeType: 'text/markdown',
+      text: body,
+    }],
+  };
+}
+
+module.exports = { SCHEME, buildList, readResource };