oh-my-codex-cli 0.1.0

package/src/config/generator.js

@@ -0,0 +1,119 @@
+/* eslint-disable no-useless-escape */
+const fs = require('fs');
+const path = require('path');
+
+function stripManagedBlock(content, startMarker, endMarker) {
+  const start = content.indexOf(startMarker);
+  if (start < 0) return content;
+  const end = content.indexOf(endMarker, start);
+  if (end < 0) return content;
+  const tailIndex = end + endMarker.length;
+  const before = content.slice(0, start).trimEnd();
+  const after = content.slice(tailIndex).trimStart();
+  return [before, after].filter(Boolean).join('\n\n');
+}
+
+function upsertFeatureFlags(config) {
+  const lines = config.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+
+  if (start < 0) {
+    const append = [
+      '[features]',
+      'multi_agent = true',
+      'child_agents_md = true',
+      'collaboration_modes = true',
+      '',
+    ].join('\n');
+    return `${config.trimEnd()}\n\n${append}`.trim() + '\n';
+  }
+
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s*\[[^\]]+\]\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+
+  const featureKeys = new Map([
+    ['multi_agent', 'multi_agent = true'],
+    ['child_agents_md', 'child_agents_md = true'],
+    ['collaboration_modes', 'collaboration_modes = true'],
+  ]);
+
+  for (const [key, value] of featureKeys.entries()) {
+    let found = false;
+    for (let i = start + 1; i < end; i += 1) {
+      if (new RegExp(`^\\s*${key}\\s*=`).test(lines[i])) {
+        lines[i] = value;
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      lines.splice(end, 0, value);
+      end += 1;
+    }
+  }
+
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function buildManagedBlock(root, options = {}) {
+  const notifyScript = path.join(root, 'scripts', 'notify-dispatch.js').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const stateServer = path.join(root, 'src', 'mcp', 'state-server.js').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const memoryServer = path.join(root, 'src', 'mcp', 'memory-server.js').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const traceServer = path.join(root, 'src', 'mcp', 'trace-server.js').replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  const includeContext7 = options.enableContext7 === true;
+
+  const lines = [
+    '# ============================================================',
+    '# oh-my-codex managed block',
+    '# ============================================================',
+    `notify = ["node", "${notifyScript}"]`,
+    'model_reasoning_effort = "high"',
+    '[mcp_servers.openaiDeveloperDocs]',
+    'url = "https://developers.openai.com/mcp"',
+    'enabled = true',
+    '',
+    '[mcp_servers.omcodex_state]',
+    'command = "node"',
+    `args = ["${stateServer}"]`,
+    'enabled = true',
+    '',
+    '[mcp_servers.omcodex_memory]',
+    'command = "node"',
+    `args = ["${memoryServer}"]`,
+    'enabled = true',
+    '',
+    '[mcp_servers.omcodex_trace]',
+    'command = "node"',
+    `args = ["${traceServer}"]`,
+    'enabled = true',
+  ];
+
+  if (includeContext7) {
+    lines.push('', '[mcp_servers.context7]', 'command = "npx"', 'args = ["-y", "@upstash/context7-mcp"]', 'enabled = true');
+  }
+
+  lines.push('', '# ============================================================', '# end oh-my-codex managed block', '# ============================================================');
+  return lines.join('\n');
+}
+
+function mergeConfig(configFile, root, options = {}) {
+  const dir = path.dirname(configFile);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const startMarker = '# oh-my-codex managed block';
+  const endMarker = '# end oh-my-codex managed block';
+  const existing = fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf8') : '';
+  let next = stripManagedBlock(existing, startMarker, endMarker).trim();
+  next = upsertFeatureFlags(next);
+
+  const managed = buildManagedBlock(root, options);
+  const output = `${next.trim()}\n\n${managed}\n`;
+  fs.writeFileSync(configFile, output, 'utf8');
+}
+
+module.exports = { mergeConfig };

package/src/mcp/memory-server.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+const { Server } = require('@modelcontextprotocol/sdk/server');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { ListToolsRequestSchema, CallToolRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+
+function text(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+
+function memoryPath(cwd) {
+  return path.join(cwd, '.omcodex', 'project-memory.json');
+}
+
+function notepadPath(cwd) {
+  return path.join(cwd, '.omcodex', 'notepad.md');
+}
+
+function tokenize(input) {
+  return String(input || '')
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+function flattenJson(value, prefix = '') {
+  const docs = [];
+  if (value === null || value === undefined) return docs;
+
+  if (typeof value !== 'object') {
+    docs.push({ id: prefix || 'root', text: `${prefix}: ${String(value)}`, source: 'project-memory' });
+    return docs;
+  }
+
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i += 1) {
+      const nextPrefix = prefix ? `${prefix}[${i}]` : `[${i}]`;
+      docs.push(...flattenJson(value[i], nextPrefix));
+    }
+    return docs;
+  }
+
+  for (const [key, child] of Object.entries(value)) {
+    const nextPrefix = prefix ? `${prefix}.${key}` : key;
+    docs.push(...flattenJson(child, nextPrefix));
+  }
+
+  return docs;
+}
+
+function scoreDocuments(query, docs, limit = 5) {
+  const queryTokens = tokenize(query);
+  if (queryTokens.length === 0) return [];
+  const querySet = new Set(queryTokens);
+
+  const df = {};
+  const tokenizedDocs = docs.map((doc) => {
+    const tokens = tokenize(doc.text);
+    const unique = new Set(tokens);
+    for (const token of unique) df[token] = (df[token] || 0) + 1;
+    return { doc, tokens };
+  });
+
+  const idf = {};
+  const docCount = Math.max(1, tokenizedDocs.length);
+  for (const token of Object.keys(df)) {
+    idf[token] = Math.log((docCount + 1) / (df[token] + 1)) + 1;
+  }
+
+  const scored = tokenizedDocs.map(({ doc, tokens }) => {
+    const tf = {};
+    for (const token of tokens) tf[token] = (tf[token] || 0) + 1;
+
+    let dot = 0;
+    let qNorm = 0;
+    let dNorm = 0;
+    for (const token of querySet) {
+      const qWeight = idf[token] || 1;
+      const dWeight = (tf[token] || 0) * (idf[token] || 1);
+      dot += qWeight * dWeight;
+      qNorm += qWeight * qWeight;
+    }
+
+    for (const [token, freq] of Object.entries(tf)) {
+      const weight = freq * (idf[token] || 1);
+      dNorm += weight * weight;
+    }
+
+    const cosine = qNorm > 0 && dNorm > 0 ? dot / (Math.sqrt(qNorm) * Math.sqrt(dNorm)) : 0;
+    const overlap = tokens.filter((token) => querySet.has(token)).length / Math.max(1, querySet.size);
+    const score = (cosine * 0.7) + (overlap * 0.3);
+
+    return {
+      source: doc.source,
+      id: doc.id,
+      score: Number(score.toFixed(4)),
+      snippet: doc.text.slice(0, 280),
+    };
+  });
+
+  return scored
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, Math.max(1, Number(limit) || 5));
+}
+
+async function loadSemanticDocuments(wd) {
+  const docs = [];
+
+  const memoryFile = memoryPath(wd);
+  if (fs.existsSync(memoryFile)) {
+    try {
+      const memory = JSON.parse(await fsp.readFile(memoryFile, 'utf8'));
+      docs.push(...flattenJson(memory));
+    } catch {}
+  }
+
+  const notesFile = notepadPath(wd);
+  if (fs.existsSync(notesFile)) {
+    const raw = await fsp.readFile(notesFile, 'utf8');
+    const blocks = raw.split(/\n{2,}/).map((item) => item.trim()).filter(Boolean);
+    for (let i = 0; i < blocks.length; i += 1) {
+      docs.push({
+        source: 'notepad',
+        id: `note-${i + 1}`,
+        text: blocks[i],
+      });
+    }
+  }
+
+  return docs;
+}
+
+const server = new Server({ name: 'omcodex-memory', version: '0.1.0' }, { capabilities: { tools: {} } });
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'project_memory_read',
+      description: 'Read project memory',
+      inputSchema: { type: 'object', properties: { workingDirectory: { type: 'string' } } },
+    },
+    {
+      name: 'project_memory_write',
+      description: 'Write project memory',
+      inputSchema: {
+        type: 'object',
+        properties: { memory: { type: 'object' }, workingDirectory: { type: 'string' } },
+        required: ['memory'],
+      },
+    },
+    {
+      name: 'notepad_read',
+      description: 'Read notepad',
+      inputSchema: { type: 'object', properties: { workingDirectory: { type: 'string' } } },
+    },
+    {
+      name: 'notepad_write',
+      description: 'Append notepad entry',
+      inputSchema: {
+        type: 'object',
+        properties: { content: { type: 'string' }, workingDirectory: { type: 'string' } },
+        required: ['content'],
+      },
+    },
+    {
+      name: 'memory_search',
+      description: 'Semantic search across project memory and notepad',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+          limit: { type: 'number' },
+          workingDirectory: { type: 'string' },
+        },
+        required: ['query'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const a = args || {};
+  const wd = typeof a.workingDirectory === 'string' ? a.workingDirectory : process.cwd();
+
+  if (name === 'project_memory_read') {
+    const file = memoryPath(wd);
+    if (!fs.existsSync(file)) return text({ exists: false });
+    const content = JSON.parse(await fsp.readFile(file, 'utf8'));
+    return text({ exists: true, memory: content });
+  }
+
+  if (name === 'project_memory_write') {
+    const file = memoryPath(wd);
+    await fsp.mkdir(path.dirname(file), { recursive: true });
+    await fsp.writeFile(file, `${JSON.stringify(a.memory, null, 2)}\n`, 'utf8');
+    return text({ success: true });
+  }
+
+  if (name === 'notepad_read') {
+    const file = notepadPath(wd);
+    if (!fs.existsSync(file)) return text({ exists: false, content: '' });
+    const content = await fsp.readFile(file, 'utf8');
+    return text({ exists: true, content });
+  }
+
+  if (name === 'notepad_write') {
+    const file = notepadPath(wd);
+    await fsp.mkdir(path.dirname(file), { recursive: true });
+    const entry = `\n[${new Date().toISOString()}] ${String(a.content)}\n`;
+    await fsp.appendFile(file, entry, 'utf8');
+    return text({ success: true });
+  }
+
+  if (name === 'memory_search') {
+    const docs = await loadSemanticDocuments(wd);
+    const matches = scoreDocuments(a.query, docs, a.limit);
+    return text({
+      total_documents: docs.length,
+      query: a.query,
+      count: matches.length,
+      matches,
+    });
+  }
+
+  return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/mcp/state-server.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+const { Server } = require('@modelcontextprotocol/sdk/server');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { ListToolsRequestSchema, CallToolRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+
+const SUPPORTED_MODES = ['autopilot', 'ultrawork', 'ralph', 'ultraqa', 'plan', 'swarm', 'pipeline', 'ecomode'];
+
+function statePath(cwd, mode) {
+  return path.join(cwd, '.omcodex', 'state', `${mode}-state.json`);
+}
+
+function text(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+
+const server = new Server({ name: 'omcodex-state', version: '0.1.0' }, { capabilities: { tools: {} } });
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'state_read',
+      description: 'Read mode state',
+      inputSchema: {
+        type: 'object',
+        properties: { mode: { type: 'string', enum: SUPPORTED_MODES }, workingDirectory: { type: 'string' } },
+        required: ['mode'],
+      },
+    },
+    {
+      name: 'state_write',
+      description: 'Write mode state',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          mode: { type: 'string', enum: SUPPORTED_MODES },
+          state: { type: 'object' },
+          workingDirectory: { type: 'string' },
+        },
+        required: ['mode', 'state'],
+      },
+    },
+    {
+      name: 'state_clear',
+      description: 'Delete mode state',
+      inputSchema: {
+        type: 'object',
+        properties: { mode: { type: 'string', enum: SUPPORTED_MODES }, workingDirectory: { type: 'string' } },
+        required: ['mode'],
+      },
+    },
+    {
+      name: 'state_list_active',
+      description: 'List active mode states',
+      inputSchema: { type: 'object', properties: { workingDirectory: { type: 'string' } } },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const a = args || {};
+  const wd = typeof a.workingDirectory === 'string' ? a.workingDirectory : process.cwd();
+
+  if (name === 'state_read') {
+    const file = statePath(wd, a.mode);
+    if (!fs.existsSync(file)) return text({ exists: false });
+    const state = JSON.parse(await fsp.readFile(file, 'utf8'));
+    return text({ exists: true, state });
+  }
+
+  if (name === 'state_write') {
+    const file = statePath(wd, a.mode);
+    await fsp.mkdir(path.dirname(file), { recursive: true });
+    await fsp.writeFile(file, `${JSON.stringify(a.state, null, 2)}\n`, 'utf8');
+    return text({ success: true });
+  }
+
+  if (name === 'state_clear') {
+    const file = statePath(wd, a.mode);
+    if (fs.existsSync(file)) await fsp.unlink(file);
+    return text({ success: true });
+  }
+
+  if (name === 'state_list_active') {
+    const stateDir = path.join(wd, '.omcodex', 'state');
+    if (!fs.existsSync(stateDir)) return text({ active: [] });
+    const files = (await fsp.readdir(stateDir)).filter((file) => file.endsWith('-state.json'));
+    const active = [];
+    for (const file of files) {
+      try {
+        const payload = JSON.parse(await fsp.readFile(path.join(stateDir, file), 'utf8'));
+        if (payload && payload.active) active.push(file.replace('-state.json', ''));
+      } catch {}
+    }
+    return text({ active });
+  }
+
+  return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/mcp/trace-server.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+const { Server } = require('@modelcontextprotocol/sdk/server');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { ListToolsRequestSchema, CallToolRequestSchema } = require('@modelcontextprotocol/sdk/types.js');
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+
+function text(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+}
+
+async function readJsonl(logDir, last) {
+  if (!fs.existsSync(logDir)) return [];
+  const files = (await fsp.readdir(logDir)).filter((file) => file.endsWith('.jsonl')).sort();
+  const entries = [];
+
+  for (const file of files) {
+    const raw = await fsp.readFile(path.join(logDir, file), 'utf8');
+    for (const line of raw.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        entries.push(JSON.parse(line));
+      } catch {}
+    }
+  }
+
+  if (typeof last === 'number' && last > 0) return entries.slice(-last);
+  return entries;
+}
+
+function isErrorEntry(entry) {
+  if (!entry || typeof entry !== 'object') return false;
+  if (entry.ok === false) return true;
+  if (typeof entry.status === 'string' && ['error', 'timeout', 'failed'].includes(entry.status)) return true;
+  if (typeof entry.error === 'string' && entry.error.trim() !== '') return true;
+  if (typeof entry.reason === 'string' && entry.reason.includes('failed')) return true;
+  return false;
+}
+
+function summarizeByType(entries) {
+  const byType = {};
+  for (const item of entries) {
+    const type = item.type || 'unknown';
+    byType[type] = (byType[type] || 0) + 1;
+  }
+  return byType;
+}
+
+function buildRecommendations(entries) {
+  const recommendations = [];
+  const disabledNotify = entries.filter((entry) => entry.type === 'notify_dispatch' && entry.enabled === false).length;
+  const pluginErrors = entries.filter((entry) => entry.type === 'notify_plugin_dispatch' && entry.ok === false).length;
+  const teamFixTransitions = entries.filter((entry) => entry.type === 'team_auto_advance' && entry.to === 'team-fix').length;
+  const totalErrors = entries.filter((entry) => isErrorEntry(entry)).length;
+
+  if (disabledNotify > 0) {
+    recommendations.push({
+      skill: 'verify',
+      priority: 'high',
+      reason: `notify pipeline disabled ${disabledNotify} time(s); enable OMX_NOTIFY_PLUGINS=1 and validate plugins`,
+    });
+  }
+
+  if (pluginErrors > 0) {
+    recommendations.push({
+      skill: 'build-fix',
+      priority: 'high',
+      reason: `notify plugins failed ${pluginErrors} time(s); run notify validate/test and fix plugin runtime`,
+    });
+  }
+
+  if (teamFixTransitions > 0) {
+    recommendations.push({
+      skill: 'ultraqa',
+      priority: 'medium',
+      reason: `team auto-flow entered fix loop ${teamFixTransitions} time(s); run QA loop before advancing`,
+    });
+  }
+
+  if (totalErrors > 0) {
+    recommendations.push({
+      skill: 'debug-analysis',
+      priority: 'medium',
+      reason: `found ${totalErrors} error-like trace entries; investigate root causes before scaling parallel work`,
+    });
+  }
+
+  if (recommendations.length === 0) {
+    recommendations.push({
+      skill: 'autopilot',
+      priority: 'low',
+      reason: 'no major issues detected in traces; continue feature execution',
+    });
+  }
+
+  return recommendations;
+}
+
+function diagnose(entries) {
+  const byType = summarizeByType(entries);
+  const allErrors = entries.filter((entry) => isErrorEntry(entry));
+  const recentErrors = allErrors.slice(-20);
+  return {
+    total: entries.length,
+    byType,
+    error_count: allErrors.length,
+    recent_errors: recentErrors,
+    recommendations: buildRecommendations(entries),
+  };
+}
+
+const server = new Server({ name: 'omcodex-trace', version: '0.1.0' }, { capabilities: { tools: {} } });
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'trace_timeline',
+      description: 'Read recent trace entries',
+      inputSchema: { type: 'object', properties: { last: { type: 'number' }, workingDirectory: { type: 'string' } } },
+    },
+    {
+      name: 'trace_summary',
+      description: 'Get trace summary counters',
+      inputSchema: { type: 'object', properties: { workingDirectory: { type: 'string' } } },
+    },
+    {
+      name: 'trace_diagnose',
+      description: 'Diagnose trace patterns and recommend next skills',
+      inputSchema: { type: 'object', properties: { last: { type: 'number' }, workingDirectory: { type: 'string' } } },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const a = args || {};
+  const wd = typeof a.workingDirectory === 'string' ? a.workingDirectory : process.cwd();
+  const logsDir = path.join(wd, '.omcodex', 'logs');
+
+  if (name === 'trace_timeline') {
+    const entries = await readJsonl(logsDir, a.last);
+    return text({ count: entries.length, entries });
+  }
+
+  if (name === 'trace_summary') {
+    const entries = await readJsonl(logsDir);
+    const byType = summarizeByType(entries);
+    return text({ total: entries.length, byType });
+  }
+
+  if (name === 'trace_diagnose') {
+    const entries = await readJsonl(logsDir, a.last);
+    return text(diagnose(entries));
+  }
+
+  return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});