oh-my-codex-cli 0.1.0

package/src/notify/dispatch.js

@@ -0,0 +1,74 @@
+const { buildNotifyEvent } = require('./extensibility/events');
+const { dispatchNotifyEvent } = require('./extensibility/dispatcher');
+const { applyTeamAutoAdvance } = require('../team/auto-advance');
+
+function pickString(payload, keys) {
+  for (const key of keys) {
+    const value = payload ? payload[key] : undefined;
+    if (typeof value === 'string' && value.trim() !== '') return value;
+  }
+  return undefined;
+}
+
+function normalizeNotifyEventName(rawType) {
+  const type = typeof rawType === 'string' ? rawType.trim().toLowerCase() : '';
+  if (!type) return null;
+
+  if (type === 'agent-turn-complete' || type === 'turn-complete' || type === 'turn_complete') {
+    return 'turn-complete';
+  }
+  if (type === 'session-start' || type === 'session_start' || type === 'start') {
+    return 'session-start';
+  }
+  if (type === 'session-end' || type === 'session_end' || type === 'session-stop' || type === 'stop' || type === 'end') {
+    return 'session-end';
+  }
+  if (type === 'session-idle' || type === 'session_idle' || type === 'idle') {
+    return 'session-idle';
+  }
+  if (type === 'needs-input' || type === 'needs_input') {
+    return 'needs-input';
+  }
+  if (type === 'pre-tool-use' || type === 'pre_tool_use') {
+    return 'pre-tool-use';
+  }
+  if (type === 'post-tool-use' || type === 'post_tool_use') {
+    return 'post-tool-use';
+  }
+  return null;
+}
+
+function toNotifyEvent(payload) {
+  const normalizedEvent = normalizeNotifyEventName(
+    pickString(payload, ['type', 'event', 'event_type', 'event-type']),
+  );
+  if (!normalizedEvent) return null;
+
+  return buildNotifyEvent(normalizedEvent, {
+    source: 'native',
+    session_id: pickString(payload, ['session_id', 'session-id', 'sessionId']),
+    thread_id: pickString(payload, ['thread_id', 'thread-id', 'threadId']),
+    turn_id: pickString(payload, ['turn_id', 'turn-id', 'turnId']),
+    mode: pickString(payload, ['mode']),
+    context: {
+      cwd: payload ? payload.cwd : undefined,
+      payload_type: pickString(payload, ['type']),
+      last_assistant_message: pickString(payload, ['last-assistant-message', 'last_assistant_message']),
+    },
+  });
+}
+
+async function dispatchFromNotifyPayload(payload, options = {}) {
+  const event = toNotifyEvent(payload);
+  if (!event) return { enabled: false, event: 'unsupported', plugin_count: 0, results: [] };
+  const dispatch = await dispatchNotifyEvent(event, options);
+  const teamAutoAdvance = await applyTeamAutoAdvance(event, { cwd: options.cwd || process.cwd() });
+  return {
+    ...dispatch,
+    team_auto_advance: teamAutoAdvance,
+  };
+}
+
+module.exports = {
+  dispatchFromNotifyPayload,
+};

package/src/notify/extensibility/dispatcher.js

@@ -0,0 +1,113 @@
+const fs = require('fs/promises');
+const path = require('path');
+const { pathToFileURL } = require('url');
+const {
+  discoverNotifyPlugins,
+  isNotifyPluginsEnabled,
+  resolveNotifyPluginTimeoutMs,
+} = require('./loader');
+
+function notifyLogPath(cwd) {
+  const day = new Date().toISOString().slice(0, 10);
+  return path.join(cwd, '.omcodex', 'logs', `notify-${day}.jsonl`);
+}
+
+async function appendLog(cwd, payload) {
+  const file = notifyLogPath(cwd);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.appendFile(file, `${JSON.stringify({ timestamp: new Date().toISOString(), ...payload })}\n`, 'utf8');
+}
+
+function withTimeout(promise, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('timeout')), timeoutMs);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+
+function buildSdk(cwd, pluginId) {
+  const pluginStateDir = path.join(cwd, '.omcodex', 'state', 'notify-plugins', pluginId);
+
+  async function readState(key) {
+    const file = path.join(pluginStateDir, `${key}.json`);
+    try {
+      const raw = await fs.readFile(file, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  async function writeState(key, value) {
+    const file = path.join(pluginStateDir, `${key}.json`);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  }
+
+  async function deleteState(key) {
+    const file = path.join(pluginStateDir, `${key}.json`);
+    try { await fs.unlink(file); } catch {}
+  }
+
+  return {
+    log: {
+      info: async (message, meta) => appendLog(cwd, { type: 'notify_plugin_log', level: 'info', plugin: pluginId, message, meta }),
+      warn: async (message, meta) => appendLog(cwd, { type: 'notify_plugin_log', level: 'warn', plugin: pluginId, message, meta }),
+      error: async (message, meta) => appendLog(cwd, { type: 'notify_plugin_log', level: 'error', plugin: pluginId, message, meta }),
+    },
+    state: {
+      read: readState,
+      write: writeState,
+      delete: deleteState,
+    },
+  };
+}
+
+async function dispatchNotifyEvent(event, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const enabled = options.enabled !== false && isNotifyPluginsEnabled(options.env || process.env);
+  const plugins = discoverNotifyPlugins(cwd);
+
+  const summary = {
+    enabled,
+    event: event.event,
+    plugin_count: plugins.length,
+    results: [],
+  };
+
+  if (!enabled) {
+    await appendLog(cwd, { type: 'notify_dispatch', enabled: false, reason: 'plugins_disabled', event: event.event });
+    return summary;
+  }
+
+  const timeoutMs = resolveNotifyPluginTimeoutMs(options.env || process.env);
+
+  for (const plugin of plugins) {
+    const started = Date.now();
+    try {
+      const mod = await import(`${pathToFileURL(plugin.filePath).href}?t=${Date.now()}`);
+      if (typeof mod.onNotifyEvent !== 'function') {
+        summary.results.push({ plugin: plugin.id, ok: false, status: 'invalid_export', duration_ms: Date.now() - started });
+        await appendLog(cwd, { type: 'notify_plugin_dispatch', plugin: plugin.id, event: event.event, ok: false, status: 'invalid_export' });
+        continue;
+      }
+
+      const sdk = buildSdk(cwd, plugin.id);
+      await withTimeout(Promise.resolve(mod.onNotifyEvent(event, sdk)), timeoutMs);
+      summary.results.push({ plugin: plugin.id, ok: true, status: 'ok', duration_ms: Date.now() - started });
+      await appendLog(cwd, { type: 'notify_plugin_dispatch', plugin: plugin.id, event: event.event, ok: true, status: 'ok' });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const status = message === 'timeout' ? 'timeout' : 'error';
+      summary.results.push({ plugin: plugin.id, ok: false, status, error: message, duration_ms: Date.now() - started });
+      await appendLog(cwd, { type: 'notify_plugin_dispatch', plugin: plugin.id, event: event.event, ok: false, status, error: message });
+    }
+  }
+
+  return summary;
+}
+
+module.exports = {
+  dispatchNotifyEvent,
+};

package/src/notify/extensibility/events.js

@@ -0,0 +1,15 @@
+function buildNotifyEvent(event, payload = {}) {
+  return {
+    schema_version: '1',
+    event,
+    timestamp: new Date().toISOString(),
+    source: payload.source || 'native',
+    context: payload.context || {},
+    session_id: payload.session_id,
+    thread_id: payload.thread_id,
+    turn_id: payload.turn_id,
+    mode: payload.mode,
+  };
+}
+
+module.exports = { buildNotifyEvent };

package/src/notify/extensibility/loader.js

@@ -0,0 +1,54 @@
+const fs = require('fs');
+const path = require('path');
+
+function notifyPluginsDir(cwd) {
+  return path.join(cwd, '.omcodex', 'notify');
+}
+
+function legacyNotifyPluginsDir(cwd) {
+  return path.join(cwd, '.omcodex', 'notify-plugins');
+}
+
+function discoverNotifyPlugins(cwd = process.cwd()) {
+  const primaryDir = notifyPluginsDir(cwd);
+  const legacyDir = legacyNotifyPluginsDir(cwd);
+  const candidates = [primaryDir, legacyDir];
+  const seen = new Set();
+  const plugins = [];
+
+  for (const dir of candidates) {
+    if (!fs.existsSync(dir)) continue;
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.endsWith('.mjs') && !file.endsWith('.js')) continue;
+      const key = `${dir}/${file}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      plugins.push({
+        id: file.replace(/\.(mjs|js)$/i, ''),
+        fileName: file,
+        filePath: path.join(dir, file),
+        legacy: dir === legacyDir,
+      });
+    }
+  }
+
+  return plugins.sort((a, b) => a.fileName.localeCompare(b.fileName));
+}
+
+function isNotifyPluginsEnabled(env = process.env) {
+  return env.OMX_NOTIFY_PLUGINS === '1';
+}
+
+function resolveNotifyPluginTimeoutMs(env = process.env) {
+  const raw = Number.parseInt(String(env.OMX_NOTIFY_PLUGIN_TIMEOUT_MS || ''), 10);
+  if (Number.isFinite(raw) && raw >= 100 && raw <= 60000) return raw;
+  return 1500;
+}
+
+module.exports = {
+  notifyPluginsDir,
+  legacyNotifyPluginsDir,
+  discoverNotifyPlugins,
+  isNotifyPluginsEnabled,
+  resolveNotifyPluginTimeoutMs,
+};

package/src/router/skill-router.js

@@ -0,0 +1,90 @@
+const { tryReadCatalogManifest } = require('../catalog/reader');
+
+const ROUTE_RULES = [
+  { skill: 'plan', weight: 3, keywords: ['plan', '规划', '设计', 'architecture', '架构', '方案', 'roadmap'] },
+  { skill: 'research', weight: 3, keywords: ['research', '调研', 'compare', '对比', 'benchmark'] },
+  { skill: 'code-review', weight: 4, keywords: ['review', 'code review', '审查', '评审'] },
+  { skill: 'security-review', weight: 4, keywords: ['security', 'auth', '鉴权', '漏洞', '安全'] },
+  { skill: 'build-fix', weight: 4, keywords: ['build error', 'compile', 'type error', 'lint', '失败', '报错'] },
+  { skill: 'verify', weight: 3, keywords: ['verify', '验证', 'check', '检查'] },
+  { skill: 'tdd', weight: 3, keywords: ['tdd', 'test first', '测试先行'] },
+  { skill: 'tdd-workflow', weight: 2, keywords: ['unit test', 'integration test', 'e2e', 'coverage'] },
+  { skill: 'ultraqa', weight: 3, keywords: ['qa', '回归', 'quality loop', '质量闭环'] },
+  { skill: 'autopilot', weight: 3, keywords: ['implement', '实现', '开发', 'build feature', '交付'] },
+  { skill: 'start-dev', weight: 3, keywords: ['start', 'kickoff', '开始开发', '新功能'] },
+  { skill: 'swarm', weight: 2, keywords: ['parallel', '并行', 'multi-agent', '多代理'] },
+  { skill: 'ultrawork', weight: 2, keywords: ['batch', '批量', 'high throughput', '大量'] },
+  { skill: 'backend-patterns', weight: 2, keywords: ['api', 'backend', '数据库', 'service'] },
+  { skill: 'frontend-patterns', weight: 2, keywords: ['frontend', 'ui', '组件', '页面'] },
+  { skill: 'frontend-ui-ux', weight: 2, keywords: ['ux', '视觉', '交互', '界面设计'] },
+  { skill: 'debug-analysis', weight: 3, keywords: ['debug', '定位问题', '根因', 'trace'] },
+];
+
+function normalizeText(input) {
+  return String(input || '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+function countHits(text, keywords) {
+  let hits = 0;
+  for (const keyword of keywords) {
+    const token = normalizeText(keyword);
+    if (!token) continue;
+    if (text.includes(token)) hits += 1;
+  }
+  return hits;
+}
+
+function catalogSkills(root) {
+  const manifest = tryReadCatalogManifest(root);
+  if (!manifest) return null;
+  return new Set(manifest.skills.filter((skill) => skill.status === 'active').map((skill) => skill.name));
+}
+
+function routeTaskToSkills(taskDescription, options = {}) {
+  const text = normalizeText(taskDescription);
+  const limit = Math.max(1, Number(options.limit) || 5);
+  const root = options.root;
+  const available = catalogSkills(root);
+
+  const scored = [];
+  for (const rule of ROUTE_RULES) {
+    if (available && !available.has(rule.skill)) continue;
+    const hits = countHits(text, rule.keywords);
+    if (hits === 0) continue;
+    scored.push({
+      skill: rule.skill,
+      score: hits * rule.weight,
+      hits,
+      rationale: `matched ${hits} keyword(s)`,
+    });
+  }
+
+  scored.sort((a, b) => b.score - a.score || a.skill.localeCompare(b.skill));
+
+  const unique = [];
+  const seen = new Set();
+  for (const item of scored) {
+    if (seen.has(item.skill)) continue;
+    seen.add(item.skill);
+    unique.push(item);
+  }
+
+  if (unique.length === 0) {
+    if (!available || available.has('autopilot')) unique.push({ skill: 'autopilot', score: 1, hits: 0, rationale: 'default execution fallback' });
+    if (!available || available.has('plan')) unique.push({ skill: 'plan', score: 1, hits: 0, rationale: 'default planning fallback' });
+  }
+
+  const top = unique.slice(0, limit);
+  const totalScore = top.reduce((sum, item) => sum + item.score, 0);
+  const confidence = Math.min(1, totalScore / 12);
+
+  return {
+    task: String(taskDescription || ''),
+    confidence,
+    recommendations: top,
+  };
+}
+
+module.exports = {
+  routeTaskToSkills,
+};

package/src/team/auto-advance.js

@@ -0,0 +1,72 @@
+const fs = require('fs/promises');
+const path = require('path');
+const { readTeamState, writeTeamState } = require('./state-store');
+const { transitionPhase } = require('./orchestrator');
+
+const FAILURE_HINT = /\b(fail(?:ed|ure)?|error|exception|timeout|lint|type\s*error|test(?:s)?\s+failed)\b/i;
+
+function isFailureSignal(event) {
+  const context = event && typeof event.context === 'object' ? event.context : {};
+  const message = String(context.last_assistant_message || '');
+  return FAILURE_HINT.test(message);
+}
+
+function nextPhaseFor(state, event, failed) {
+  const name = event ? event.event : '';
+  if (state.phase === 'team-plan' && name === 'turn-complete') return 'team-prd';
+  if (state.phase === 'team-prd' && name === 'turn-complete') return 'team-exec';
+
+  if (state.phase === 'team-exec') {
+    if (failed) return 'team-fix';
+    if (name === 'post-tool-use' || name === 'turn-complete') return 'team-verify';
+  }
+
+  if (state.phase === 'team-verify') {
+    if (failed) return 'team-fix';
+    if (name === 'turn-complete') return 'complete';
+  }
+
+  if (state.phase === 'team-fix' && name === 'turn-complete') {
+    return failed ? 'failed' : 'team-exec';
+  }
+
+  return null;
+}
+
+function teamAutoLogPath(cwd) {
+  const day = new Date().toISOString().slice(0, 10);
+  return path.join(cwd, '.omcodex', 'logs', `team-auto-${day}.jsonl`);
+}
+
+async function appendTeamAutoLog(cwd, payload) {
+  const file = teamAutoLogPath(cwd);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.appendFile(file, `${JSON.stringify({ timestamp: new Date().toISOString(), ...payload })}\n`, 'utf8');
+}
+
+async function applyTeamAutoAdvance(event, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const state = readTeamState(cwd);
+  if (!state || !state.active) return { applied: false, reason: 'inactive_or_missing' };
+  if (state.auto_advance !== true) return { applied: false, reason: 'auto_advance_disabled' };
+
+  const failed = isFailureSignal(event);
+  const nextPhase = nextPhaseFor(state, event, failed);
+  if (!nextPhase) return { applied: false, reason: 'no_transition' };
+
+  try {
+    const next = transitionPhase(state, nextPhase, `notify:${event.event}${failed ? ':failure' : ''}`);
+    writeTeamState(cwd, next);
+    const result = { applied: true, from: state.phase, to: next.phase, event: event.event, failed_signal: failed };
+    await appendTeamAutoLog(cwd, { type: 'team_auto_advance', ...result });
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await appendTeamAutoLog(cwd, { type: 'team_auto_advance', applied: false, event: event.event, error: message });
+    return { applied: false, reason: 'transition_error', error: message };
+  }
+}
+
+module.exports = {
+  applyTeamAutoAdvance,
+};

package/src/team/orchestrator.js

@@ -0,0 +1,82 @@
+const TEAM_PHASES = ['team-plan', 'team-prd', 'team-exec', 'team-verify', 'team-fix'];
+const TERMINAL_PHASES = ['complete', 'failed', 'cancelled'];
+
+const TRANSITIONS = {
+  'team-plan': ['team-prd'],
+  'team-prd': ['team-exec'],
+  'team-exec': ['team-verify', 'team-fix'],
+  'team-verify': ['team-fix', 'complete', 'failed'],
+  'team-fix': ['team-exec', 'team-verify', 'complete', 'failed'],
+};
+
+function isTerminal(phase) {
+  return TERMINAL_PHASES.includes(phase);
+}
+
+function createTeamState(taskDescription, maxFixAttempts = 3, options = {}) {
+  return {
+    active: true,
+    phase: 'team-plan',
+    task_description: taskDescription,
+    auto_advance: options.autoAdvance === true,
+    created_at: new Date().toISOString(),
+    phase_transitions: [],
+    tasks: [],
+    max_fix_attempts: maxFixAttempts,
+    current_fix_attempt: 0,
+  };
+}
+
+function transitionPhase(state, to, reason) {
+  if (isTerminal(state.phase)) {
+    throw new Error(`Cannot transition from terminal phase: ${state.phase}`);
+  }
+
+  const allowed = TRANSITIONS[state.phase] || [];
+  if (!allowed.includes(to)) {
+    throw new Error(`Invalid transition: ${state.phase} -> ${to}`);
+  }
+
+  const nextFixAttempt = to === 'team-fix' ? state.current_fix_attempt + 1 : state.current_fix_attempt;
+
+  if (to === 'team-fix' && nextFixAttempt > state.max_fix_attempts) {
+    return {
+      ...state,
+      active: false,
+      phase: 'failed',
+      phase_transitions: [
+        ...state.phase_transitions,
+        {
+          from: state.phase,
+          to: 'failed',
+          at: new Date().toISOString(),
+          reason: `team-fix loop limit reached (${state.max_fix_attempts})`,
+        },
+      ],
+    };
+  }
+
+  return {
+    ...state,
+    active: !isTerminal(to),
+    phase: to,
+    current_fix_attempt: nextFixAttempt,
+    phase_transitions: [
+      ...state.phase_transitions,
+      {
+        from: state.phase,
+        to,
+        at: new Date().toISOString(),
+        reason,
+      },
+    ],
+  };
+}
+
+module.exports = {
+  TEAM_PHASES,
+  TERMINAL_PHASES,
+  createTeamState,
+  transitionPhase,
+  isTerminal,
+};

package/src/team/state-store.js

@@ -0,0 +1,33 @@
+const fs = require('fs');
+const path = require('path');
+
+function teamStatePath(cwd) {
+  return path.join(cwd, '.omcodex', 'state', 'team-state.json');
+}
+
+function readTeamState(cwd) {
+  const file = teamStatePath(cwd);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeTeamState(cwd, state) {
+  const file = teamStatePath(cwd);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+
+function clearTeamState(cwd) {
+  const file = teamStatePath(cwd);
+  if (fs.existsSync(file)) fs.unlinkSync(file);
+}
+
+module.exports = {
+  readTeamState,
+  writeTeamState,
+  clearTeamState,
+};

package/src/utils/paths.js

@@ -0,0 +1,33 @@
+const os = require('os');
+const path = require('path');
+
+function codexHome(scope, cwd) {
+  if (scope === 'user') return path.join(os.homedir(), '.codex');
+  return path.join(cwd, '.codex');
+}
+
+function codexConfigPath(scope, cwd) {
+  return path.join(codexHome(scope, cwd), 'config.toml');
+}
+
+function codexPromptsPath(scope, cwd) {
+  return path.join(codexHome(scope, cwd), 'prompts');
+}
+
+function skillsSource(root) {
+  const agentSkills = path.join(root, '.agent', 'skills');
+  const codexSkills = path.join(root, '.codex', 'skills');
+  return { agentSkills, codexSkills };
+}
+
+function promptsSource(root) {
+  return path.join(root, 'prompts');
+}
+
+module.exports = {
+  codexHome,
+  codexConfigPath,
+  codexPromptsPath,
+  skillsSource,
+  promptsSource,
+};

package/templates/AGENTS.md

@@ -0,0 +1,15 @@
+# oh-my-codex
+
+Skill pack and workflow orchestration for OpenAI Codex CLI.
+
+## Guidance
+
+- Prefer skills for reusable workflows (`$skill` or explicit skill name in prompt).
+- Use Codex native multi-agent tools when a task benefits from delegation.
+- Verify outcomes with concrete evidence before claiming completion.
+- Keep instructions concise and implementation-focused.
+
+## Notify Compatibility
+
+Codex does not expose Claude Code style pre/post tool interception lifecycle.
+This project uses event-driven extensions built on top of Codex notifications (`notify`), not execution interception.