oh-my-codex-cli 0.1.0

package/src/cli/doctor.js

@@ -0,0 +1,62 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { tryReadCatalogManifest } = require('../catalog/reader');
+
+function checkCodexCli() {
+  const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
+  return !result.error && result.status === 0;
+}
+
+async function doctor() {
+  const root = path.resolve(__dirname, '..', '..');
+  const checks = [];
+  const codexCliInstalled = checkCodexCli();
+
+  checks.push({ name: 'Codex CLI', pass: codexCliInstalled, msg: codexCliInstalled ? 'installed' : 'not found' });
+
+  const skillsRoot = fs.existsSync(path.join(root, '.agent', 'skills'))
+    ? path.join(root, '.agent', 'skills')
+    : path.join(root, '.codex', 'skills');
+  checks.push({
+    name: 'Skills source',
+    pass: fs.existsSync(skillsRoot),
+    msg: skillsRoot,
+  });
+
+  const promptsRoot = path.join(root, 'prompts');
+  checks.push({
+    name: 'Prompts source',
+    pass: fs.existsSync(promptsRoot),
+    msg: fs.existsSync(promptsRoot) ? promptsRoot : 'missing (optional)',
+  });
+
+  const manifest = tryReadCatalogManifest(root);
+  checks.push({
+    name: 'Catalog manifest',
+    pass: !!manifest,
+    msg: manifest ? `ok (${manifest.skills.length} skills)` : 'missing or invalid',
+  });
+
+  const teamStatePath = path.join(process.cwd(), '.omcodex', 'state', 'team-state.json');
+  checks.push({
+    name: 'Team state file',
+    pass: true,
+    msg: fs.existsSync(teamStatePath) ? teamStatePath : 'not initialized yet',
+  });
+
+  let passCount = 0;
+  for (const check of checks) {
+    const icon = check.pass ? '[OK]' : '[XX]';
+    if (check.pass) passCount += 1;
+    console.log(`${icon} ${check.name}: ${check.msg}`);
+  }
+
+  console.log(`\nResult: ${passCount}/${checks.length} checks passed.`);
+  if (passCount !== checks.length) {
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { doctor };

package/src/cli/index.js

@@ -0,0 +1,85 @@
+/* eslint-disable no-console */
+const { setup } = require('./setup');
+const { doctor } = require('./doctor');
+const { team } = require('./team');
+const { notify } = require('./notify');
+const { route } = require('./route');
+
+const HELP = `oh-my-codex CLI (omcodex)
+
+Usage:
+  omcodex setup [--scope user|project-local|project] [--force] [--dry-run] [--verbose] [--no-prompts]
+  omcodex doctor
+  omcodex team start \"<task>\"
+  omcodex team status
+  omcodex team advance <phase> [reason]
+  omcodex team cancel
+  omcodex team clear
+  omcodex route "<task>" [--limit 5] [--json]
+  omcodex notify init|status|validate|test [event]
+  omcodex help
+`;
+
+function parseScope(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--scope') {
+      const next = args[i + 1];
+      if (!next) throw new Error('Missing value for --scope');
+      return next;
+    }
+    if (arg.startsWith('--scope=')) {
+      return arg.slice('--scope='.length);
+    }
+  }
+  return undefined;
+}
+
+async function main(args) {
+  const command = args[0] || 'help';
+  const flags = new Set(args);
+
+  if (command === 'help' || command === '--help' || command === '-h') {
+    console.log(HELP);
+    return;
+  }
+
+  if (command === 'setup') {
+    await setup({
+      scope: parseScope(args.slice(1)),
+      force: flags.has('--force'),
+      dryRun: flags.has('--dry-run'),
+      verbose: flags.has('--verbose'),
+      enableContext7: flags.has('--enable-context7'),
+      installSkills: !flags.has('--no-skills'),
+      installPrompts: !flags.has('--no-prompts'),
+      installRules: !flags.has('--no-rules'),
+      installConfig: !flags.has('--no-config'),
+    });
+    return;
+  }
+
+  if (command === 'doctor') {
+    await doctor();
+    return;
+  }
+
+  if (command === 'team') {
+    await team(args.slice(1));
+    return;
+  }
+
+  if (command === 'notify') {
+    await notify(args.slice(1));
+    return;
+  }
+
+  if (command === 'route') {
+    await route(args.slice(1));
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+module.exports = { main };

package/src/cli/notify.js

@@ -0,0 +1,127 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const { pathToFileURL } = require('url');
+const { buildNotifyEvent } = require('../notify/extensibility/events');
+const { dispatchNotifyEvent } = require('../notify/extensibility/dispatcher');
+const {
+  discoverNotifyPlugins,
+  notifyPluginsDir,
+  legacyNotifyPluginsDir,
+} = require('../notify/extensibility/loader');
+
+const SUPPORTED_TEST_EVENTS = new Set([
+  'turn-complete',
+  'session-start',
+  'session-end',
+  'session-idle',
+  'needs-input',
+  'pre-tool-use',
+  'post-tool-use',
+]);
+
+const SAMPLE_PLUGIN = `export async function onNotifyEvent(event, sdk) {
+  if (event.event !== 'turn-complete') return;
+  const current = Number((await sdk.state.read('seen-count')) || 0);
+  const next = current + 1;
+  await sdk.state.write('seen-count', next);
+  await sdk.log.info('sample notify plugin observed turn-complete', { seen: next, turn_id: event.turn_id });
+}
+`;
+
+async function validatePlugin(filePath) {
+  try {
+    const mod = await import(`${pathToFileURL(filePath).href}?t=${Date.now()}`);
+    if (typeof mod.onNotifyEvent !== 'function') {
+      return { valid: false, reason: 'missing export onNotifyEvent(event, sdk)' };
+    }
+    return { valid: true };
+  } catch (error) {
+    return { valid: false, reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+async function notify(args) {
+  const sub = args[0] || 'status';
+  const cwd = process.cwd();
+
+  if (sub === 'init') {
+    const dir = notifyPluginsDir(cwd);
+    const file = path.join(dir, 'sample-notify-plugin.mjs');
+    await fsp.mkdir(dir, { recursive: true });
+    if (fs.existsSync(file)) {
+      console.log(`already exists: ${file}`);
+      return;
+    }
+    await fsp.writeFile(file, SAMPLE_PLUGIN, 'utf8');
+    console.log(`created ${file}`);
+    console.log('Enable notify plugins with OMX_NOTIFY_PLUGINS=1');
+    return;
+  }
+
+  if (sub === 'status') {
+    const plugins = discoverNotifyPlugins(cwd);
+    console.log(`notify plugins dir: ${notifyPluginsDir(cwd)}`);
+    console.log(`legacy notify dir: ${legacyNotifyPluginsDir(cwd)}`);
+    console.log(`plugins discovered: ${plugins.length}`);
+    for (const plugin of plugins) {
+      const legacy = plugin.legacy ? ' (legacy)' : '';
+      console.log(`- ${plugin.fileName}${legacy}`);
+    }
+    return;
+  }
+
+  if (sub === 'validate') {
+    const plugins = discoverNotifyPlugins(cwd);
+    if (plugins.length === 0) {
+      console.log('No notify plugins found.');
+      return;
+    }
+
+    let failed = 0;
+    for (const plugin of plugins) {
+      const result = await validatePlugin(plugin.filePath);
+      if (result.valid) {
+        console.log(`OK ${plugin.fileName}`);
+      } else {
+        failed += 1;
+        console.log(`XX ${plugin.fileName}: ${result.reason}`);
+      }
+    }
+
+    if (failed > 0) throw new Error(`notify validation failed (${failed})`);
+    return;
+  }
+
+  if (sub === 'test') {
+    const eventName = args[1] || 'turn-complete';
+    if (!SUPPORTED_TEST_EVENTS.has(eventName)) {
+      throw new Error(`unsupported notify test event: ${eventName}`);
+    }
+
+    const event = buildNotifyEvent(eventName, {
+      source: 'native',
+      session_id: 'notify-test',
+      thread_id: `thread-${Date.now()}`,
+      turn_id: `turn-${Date.now()}`,
+      context: { reason: 'notify-test' },
+    });
+
+    const result = await dispatchNotifyEvent(event, {
+      cwd,
+      env: { ...process.env, OMX_NOTIFY_PLUGINS: '1' },
+    });
+
+    console.log(`plugins enabled: ${result.enabled ? 'yes' : 'no'}`);
+    console.log(`plugins: ${result.plugin_count}`);
+    for (const item of result.results) {
+      console.log(`${item.plugin}: ${item.status}`);
+    }
+    return;
+  }
+
+  console.log('Usage: omcodex notify init|status|validate|test [event]');
+}
+
+module.exports = { notify };

package/src/cli/route.js

@@ -0,0 +1,43 @@
+/* eslint-disable no-console */
+const path = require('path');
+const { routeTaskToSkills } = require('../router/skill-router');
+
+function parseLimit(args) {
+  for (const arg of args) {
+    if (arg.startsWith('--limit=')) return Number(arg.slice('--limit='.length));
+  }
+  const index = args.indexOf('--limit');
+  if (index >= 0 && args[index + 1]) return Number(args[index + 1]);
+  return 5;
+}
+
+function parseTask(args) {
+  return args.filter((arg) => !arg.startsWith('--limit') && arg !== '--json').join(' ').trim();
+}
+
+async function route(args) {
+  const json = args.includes('--json');
+  const limit = parseLimit(args);
+  const task = parseTask(args);
+  if (!task) {
+    throw new Error('Usage: omcodex route "<task description>" [--limit 5] [--json]');
+  }
+
+  const result = routeTaskToSkills(task, {
+    limit,
+    root: path.resolve(__dirname, '..', '..'),
+  });
+
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  console.log(`task: ${result.task}`);
+  console.log(`confidence: ${(result.confidence * 100).toFixed(0)}%`);
+  for (const item of result.recommendations) {
+    console.log(`- ${item.skill} (score=${item.score}, ${item.rationale})`);
+  }
+}
+
+module.exports = { route };

package/src/cli/setup.js

@@ -0,0 +1,155 @@
+/* eslint-disable no-console */
+const fs = require('fs');
+const fsp = require('fs/promises');
+const path = require('path');
+const os = require('os');
+const {
+  codexHome,
+  codexConfigPath,
+  codexPromptsPath,
+  skillsSource,
+  promptsSource,
+} = require('../utils/paths');
+const { mergeConfig } = require('../config/generator');
+const { getCatalogHeadlineCounts } = require('../catalog/reader');
+
+const SETUP_SCOPES = new Set(['user', 'project-local', 'project']);
+
+function readPersistedScope(cwd) {
+  const scopeFile = path.join(cwd, '.omcodex', 'setup-scope.json');
+  if (!fs.existsSync(scopeFile)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(scopeFile, 'utf8'));
+    if (SETUP_SCOPES.has(parsed.scope)) return parsed.scope;
+  } catch {}
+  return null;
+}
+
+async function persistScope(cwd, scope, dryRun) {
+  const scopeFile = path.join(cwd, '.omcodex', 'setup-scope.json');
+  if (dryRun) return;
+  await fsp.mkdir(path.dirname(scopeFile), { recursive: true });
+  await fsp.writeFile(scopeFile, `${JSON.stringify({ scope }, null, 2)}\n`, 'utf8');
+}
+
+async function copyDirectory(src, dest, options) {
+  if (!fs.existsSync(src)) return 0;
+  if (!options.dryRun) {
+    await fsp.mkdir(dest, { recursive: true });
+  }
+  const entries = await fsp.readdir(src, { withFileTypes: true });
+  let count = 0;
+
+  for (const entry of entries) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      count += await copyDirectory(from, to, options);
+      continue;
+    }
+
+    if (!entry.isFile()) continue;
+
+    if (!options.force && fs.existsSync(to)) continue;
+    if (!options.dryRun) {
+      await fsp.mkdir(path.dirname(to), { recursive: true });
+      await fsp.copyFile(from, to);
+    }
+    count += 1;
+  }
+
+  return count;
+}
+
+async function setup(options = {}) {
+  const cwd = process.cwd();
+  const root = path.resolve(__dirname, '..', '..');
+  const scope = options.scope || readPersistedScope(cwd) || 'user';
+
+  if (!SETUP_SCOPES.has(scope)) {
+    throw new Error(`Invalid scope: ${scope}. Expected one of user, project-local, project.`);
+  }
+
+  console.log('oh-my-codex setup');
+  console.log('=================');
+  console.log(`Scope: ${scope}`);
+
+  const baseCodexHome = codexHome(scope, cwd);
+  const configPath = codexConfigPath(scope, cwd);
+  const rulesSource = path.join(root, 'templates', 'rules');
+  const rulesDest = scope === 'user'
+    ? path.join(os.homedir(), '.codex', 'rules')
+    : path.join(cwd, '.codex', 'rules');
+  const promptsSrc = promptsSource(root);
+  const promptsDest = codexPromptsPath(scope, cwd);
+
+  const skillSrc = (() => {
+    const src = skillsSource(root);
+    if (fs.existsSync(src.agentSkills)) return src.agentSkills;
+    if (fs.existsSync(src.codexSkills)) return src.codexSkills;
+    throw new Error('No skills source found (.agent/skills or .codex/skills)');
+  })();
+
+  const skillsDest = scope === 'user'
+    ? path.join(os.homedir(), '.codex', 'skills')
+    : path.join(cwd, '.codex', 'skills');
+
+  await persistScope(cwd, scope, options.dryRun);
+
+  console.log('[1/5] Installing skills...');
+  const shouldInstallSkills = options.installSkills !== false && scope !== 'project';
+  const skillCount = shouldInstallSkills
+    ? await copyDirectory(skillSrc, skillsDest, options)
+    : 0;
+  if (shouldInstallSkills) {
+    const label = options.dryRun ? 'Would install/update' : 'Installed/updated';
+    console.log(`  ${label} ${skillCount} files -> ${skillsDest}`);
+  } else {
+    console.log('  Skipped for project scope');
+  }
+
+  console.log('[2/5] Installing prompts...');
+  const shouldInstallPrompts = options.installPrompts !== false && scope !== 'project';
+  if (!shouldInstallPrompts) {
+    console.log('  Skipped (--no-prompts or project scope)');
+  } else if (!fs.existsSync(promptsSrc)) {
+    console.log(`  Skipped (missing prompts source: ${promptsSrc})`);
+  } else {
+    const promptCount = await copyDirectory(promptsSrc, promptsDest, options);
+    const label = options.dryRun ? 'Would install/update' : 'Installed/updated';
+    console.log(`  ${label} ${promptCount} files -> ${promptsDest}`);
+  }
+
+  console.log('[3/5] Installing rules...');
+  if (options.installRules !== false) {
+    const ruleCount = await copyDirectory(rulesSource, rulesDest, options);
+    const label = options.dryRun ? 'Would install/update' : 'Installed/updated';
+    console.log(`  ${label} ${ruleCount} files -> ${rulesDest}`);
+  } else {
+    console.log('  Skipped (--no-rules)');
+  }
+
+  console.log('[4/5] Merging config.toml...');
+  if (options.installConfig !== false && !options.dryRun) {
+    mergeConfig(configPath, root, { enableContext7: options.enableContext7 });
+  }
+  if (options.installConfig !== false) {
+    const label = options.dryRun ? 'Would update' : 'Updated';
+    console.log(`  ${label} ${configPath}`);
+  } else {
+    console.log('  Skipped (--no-config)');
+  }
+
+  console.log('[5/5] Catalog check...');
+  const headline = getCatalogHeadlineCounts(root);
+  if (headline) {
+    console.log(`  Catalog baseline: ${headline.skills} skills, ${headline.prompts} prompts`);
+  } else {
+    console.log('  Catalog manifest missing (run npm run catalog:generate)');
+  }
+
+  console.log('\nDone.');
+}
+
+module.exports = { setup };

package/src/cli/team.js

@@ -0,0 +1,125 @@
+/* eslint-disable no-console */
+const path = require('path');
+const { createTeamState, transitionPhase } = require('../team/orchestrator');
+const { readTeamState, writeTeamState, clearTeamState } = require('../team/state-store');
+const { routeTaskToSkills } = require('../router/skill-router');
+
+function usage() {
+  console.log('Usage: omcodex team start "<task>" [--auto] [--max-fix=N] | status | advance <phase> [reason] | cancel | clear');
+}
+
+function parseStartArgs(args) {
+  const taskParts = [];
+  let autoAdvance = false;
+  let maxFixAttempts = 3;
+
+  for (let i = 1; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--auto') {
+      autoAdvance = true;
+      continue;
+    }
+    if (arg === '--max-fix' && args[i + 1]) {
+      maxFixAttempts = Math.max(1, Number(args[i + 1]) || 3);
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--max-fix=')) {
+      maxFixAttempts = Math.max(1, Number(arg.slice('--max-fix='.length)) || 3);
+      continue;
+    }
+    taskParts.push(arg);
+  }
+
+  return {
+    autoAdvance,
+    maxFixAttempts,
+    task: taskParts.join(' ').trim(),
+  };
+}
+
+async function team(args) {
+  const sub = args[0];
+  const cwd = process.cwd();
+
+  if (!sub || sub === 'help') {
+    usage();
+    return;
+  }
+
+  if (sub === 'start') {
+    const { autoAdvance, maxFixAttempts, task } = parseStartArgs(args);
+    if (!task) throw new Error('Usage: omcodex team start "<task>"');
+    const state = createTeamState(task, maxFixAttempts, { autoAdvance });
+    const routed = routeTaskToSkills(task, { limit: 3, root: path.resolve(__dirname, '..', '..') });
+    state.recommended_skills = routed.recommendations.map((item) => item.skill);
+    writeTeamState(cwd, state);
+    console.log(`team started: phase=${state.phase} auto_advance=${state.auto_advance ? 'on' : 'off'}`);
+    console.log(`recommended_skills=${state.recommended_skills.join(',')}`);
+    return;
+  }
+
+  if (sub === 'status') {
+    const state = readTeamState(cwd);
+    if (!state) {
+      console.log('No team state found.');
+      return;
+    }
+    console.log(`phase=${state.phase} active=${state.active}`);
+    console.log(`fix_attempt=${state.current_fix_attempt}/${state.max_fix_attempts}`);
+    console.log(`auto_advance=${state.auto_advance === true ? 'on' : 'off'}`);
+    if (Array.isArray(state.recommended_skills) && state.recommended_skills.length > 0) {
+      console.log(`recommended_skills=${state.recommended_skills.join(',')}`);
+    }
+    console.log(`task=${state.task_description}`);
+    return;
+  }
+
+  if (sub === 'advance') {
+    const nextPhase = args[1];
+    const reason = args.slice(2).join(' ').trim() || undefined;
+    if (!nextPhase) throw new Error('Usage: omcodex team advance <phase> [reason]');
+
+    const state = readTeamState(cwd);
+    if (!state) throw new Error('No team state found. Start first with `omcodex team start`');
+    const next = transitionPhase(state, nextPhase, reason);
+    writeTeamState(cwd, next);
+    console.log(`phase advanced: ${state.phase} -> ${next.phase}`);
+    return;
+  }
+
+  if (sub === 'cancel') {
+    const state = readTeamState(cwd);
+    if (!state) {
+      console.log('No team state found.');
+      return;
+    }
+    const next = {
+      ...state,
+      active: false,
+      phase: 'cancelled',
+      phase_transitions: [
+        ...state.phase_transitions,
+        {
+          from: state.phase,
+          to: 'cancelled',
+          at: new Date().toISOString(),
+          reason: 'manual_cancel',
+        },
+      ],
+    };
+    writeTeamState(cwd, next);
+    console.log('team cancelled');
+    return;
+  }
+
+  if (sub === 'clear') {
+    clearTeamState(cwd);
+    console.log('team state cleared');
+    return;
+  }
+
+  usage();
+}
+
+module.exports = { team };