oh-my-codex 0.7.6 → 0.8.1

package/scripts/run-provider-advisor.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import process from 'process';
+import { spawnSync } from 'child_process';
+
+const PROVIDER_BINARIES = {
+  claude: 'claude',
+  gemini: 'gemini',
+};
+const ASK_ORIGINAL_TASK_ENV = 'OMX_ASK_ORIGINAL_TASK';
+
+function usage() {
+  console.error('Usage: omx ask <claude|gemini> "<prompt>"');
+  console.error('Legacy direct usage: node scripts/run-provider-advisor.js <claude|gemini> <prompt...>');
+  console.error('                 or: node scripts/run-provider-advisor.js claude --print "<prompt>"');
+  console.error('                 or: node scripts/run-provider-advisor.js gemini --prompt "<prompt>"');
+}
+
+function slugify(value) {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'task';
+}
+
+function timestampToken(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-');
+}
+
+function parseArgs(argv) {
+  const [providerRaw, ...rest] = argv;
+  const provider = (providerRaw || '').toLowerCase();
+
+  if (!provider || !(provider in PROVIDER_BINARIES)) {
+    usage();
+    process.exit(1);
+  }
+
+  if (rest.length === 0) {
+    usage();
+    process.exit(1);
+  }
+
+  if (rest[0] === '-p' || rest[0] === '--print' || rest[0] === '--prompt') {
+    const prompt = rest.slice(1).join(' ').trim();
+    if (!prompt) {
+      usage();
+      process.exit(1);
+    }
+    return { provider, prompt };
+  }
+
+  return { provider, prompt: rest.join(' ').trim() };
+}
+
+function ensureBinary(binary) {
+  const probe = spawnSync(binary, ['--version'], {
+    stdio: 'ignore',
+    encoding: 'utf8',
+  });
+
+  if (probe.error && probe.error.code === 'ENOENT') {
+    const verify = `${binary} --version`;
+    console.error(`[ask-${binary}] Missing required local CLI binary: ${binary}`);
+    console.error(`[ask-${binary}] Install/configure ${binary} CLI, then verify with: ${verify}`);
+    process.exit(1);
+  }
+}
+
+function buildSummary(exitCode, output) {
+  if (exitCode === 0) {
+    return 'Provider completed successfully. Review the raw output for details.';
+  }
+
+  const firstLine = output
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean);
+
+  return firstLine
+    ? `Provider command failed (exit ${exitCode}): ${firstLine}`
+    : `Provider command failed with exit code ${exitCode}.`;
+}
+
+function buildActionItems(exitCode) {
+  if (exitCode === 0) {
+    return ['Review the response and extract decisions you want to apply.', 'Capture follow-up implementation tasks if needed.'];
+  }
+
+  return ['Inspect the raw output error details.', 'Fix CLI/auth/environment issues and rerun the command.'];
+}
+
+async function writeArtifact({ provider, originalTask, finalPrompt, rawOutput, exitCode }) {
+  const root = process.cwd();
+  const artifactDir = join(root, '.omx', 'artifacts');
+  const slug = slugify(originalTask);
+  const timestamp = timestampToken();
+  const artifactPath = join(artifactDir, `${provider}-${slug}-${timestamp}.md`);
+
+  const summary = buildSummary(exitCode, rawOutput);
+  const actionItems = buildActionItems(exitCode);
+
+  const body = [
+    `# ${provider} advisor artifact`,
+    '',
+    `- Provider: ${provider}`,
+    `- Exit code: ${exitCode}`,
+    `- Created at: ${new Date().toISOString()}`,
+    '',
+    '## Original task',
+    '',
+    originalTask,
+    '',
+    '## Final prompt',
+    '',
+    finalPrompt,
+    '',
+    '## Raw output',
+    '',
+    '```text',
+    rawOutput || '(no output)',
+    '```',
+    '',
+    '## Concise summary',
+    '',
+    summary,
+    '',
+    '## Action items',
+    '',
+    ...actionItems.map((item) => `- ${item}`),
+    '',
+  ].join('\n');
+
+  await mkdir(artifactDir, { recursive: true });
+  await writeFile(artifactPath, body, 'utf8');
+  return artifactPath;
+}
+
+async function main() {
+  const { provider, prompt } = parseArgs(process.argv.slice(2));
+  const binary = PROVIDER_BINARIES[provider];
+
+  ensureBinary(binary);
+
+  const run = spawnSync(binary, ['-p', prompt], {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  const stdout = run.stdout || '';
+  const stderr = run.stderr || '';
+  const rawOutput = [stdout, stderr].filter(Boolean).join(stdout && stderr ? '\n\n' : '');
+  const exitCode = typeof run.status === 'number' ? run.status : 1;
+
+  const artifactPath = await writeArtifact({
+    provider,
+    originalTask: process.env[ASK_ORIGINAL_TASK_ENV] ?? prompt,
+    finalPrompt: prompt,
+    rawOutput,
+    exitCode,
+  });
+
+  console.log(artifactPath);
+
+  if (run.error) {
+    console.error(`[ask-${provider}] ${run.error.message}`);
+  }
+
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+main().catch((error) => {
+  console.error(`[run-provider-advisor] ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});

package/skills/ask-claude/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: ask-claude
+description: Ask Claude via local CLI and capture a reusable artifact
+---
+
+# Ask Claude (Local CLI)
+
+Use the locally installed Claude CLI as a direct external advisor for focused questions, reviews, or second opinions.
+
+## Usage
+
+```bash
+/ask-claude <question or task>
+```
+
+## Routing
+
+### Preferred: Local CLI execution
+Run Claude through the canonical OMX CLI command path (no MCP routing):
+
+```bash
+omx ask claude "{{ARGUMENTS}}"
+```
+
+Exact non-interactive Claude CLI command from `claude --help`:
+
+```bash
+claude -p "{{ARGUMENTS}}"
+# equivalent: claude --print "{{ARGUMENTS}}"
+```
+
+If needed, adapt to the user's installed Claude CLI variant while keeping local execution as the default path.
+
+Legacy compatibility entrypoints (`./scripts/ask-claude.sh`, `npm run ask:claude -- ...`) are transitional wrappers.
+
+### Missing binary behavior
+If `claude` is not found, do **not** switch to MCP.
+Instead:
+1. Explain that local Claude CLI is required for this skill.
+2. Ask the user to install/configure Claude CLI.
+3. Provide a quick verification command:
+
+```bash
+claude --version
+```
+
+## Artifact requirement
+After local execution, save a markdown artifact to:
+
+```text
+.omx/artifacts/claude-<slug>-<timestamp>.md
+```
+
+Minimum artifact sections:
+1. Original user task
+2. Final prompt sent to Claude CLI
+3. Claude output (raw)
+4. Concise summary
+5. Action items / next steps
+
+Task: {{ARGUMENTS}}

package/skills/ask-gemini/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: ask-gemini
+description: Ask Gemini via local CLI and capture a reusable artifact
+---
+
+# Ask Gemini (Local CLI)
+
+Use the locally installed Gemini CLI as a direct external advisor for brainstorming, design feedback, and second opinions.
+
+## Usage
+
+```bash
+/ask-gemini <question or task>
+```
+
+## Routing
+
+### Preferred: Local CLI execution
+Run Gemini through the canonical OMX CLI command path (no MCP routing):
+
+```bash
+omx ask gemini "{{ARGUMENTS}}"
+```
+
+Exact non-interactive Gemini CLI command from `gemini --help`:
+
+```bash
+gemini -p "{{ARGUMENTS}}"
+# equivalent: gemini --prompt "{{ARGUMENTS}}"
+```
+
+If needed, adapt to the user's installed Gemini CLI variant while keeping local execution as the default path.
+
+Legacy compatibility entrypoints (`./scripts/ask-gemini.sh`, `npm run ask:gemini -- ...`) are transitional wrappers.
+
+### Missing binary behavior
+If `gemini` is not found, do **not** switch to MCP.
+Instead:
+1. Explain that local Gemini CLI is required for this skill.
+2. Ask the user to install/configure Gemini CLI.
+3. Provide a quick verification command:
+
+```bash
+gemini --version
+```
+
+## Artifact requirement
+After local execution, save a markdown artifact to:
+
+```text
+.omx/artifacts/gemini-<slug>-<timestamp>.md
+```
+
+Minimum artifact sections:
+1. Original user task
+2. Final prompt sent to Gemini CLI
+3. Gemini output (raw)
+4. Concise summary
+5. Action items / next steps
+
+Task: {{ARGUMENTS}}

package/skills/autopilot/SKILL.md

@@ -32,10 +32,28 @@ Most non-trivial software tasks require coordinated phases: understanding requir
 - QA cycles repeat up to 5 times; if the same error persists 3 times, stop and report the fundamental issue
 - Validation requires approval from all reviewers; rejected items get fixed and re-validated
 - Cancel with `/cancel` at any time; progress is preserved for resume
+- If a deep-interview spec exists, use it as high-clarity phase input instead of re-expanding from scratch
+- If input is too vague for reliable expansion, offer/trigger `$deep-interview` first
+- Do not enter expansion/planning/execution-heavy phases until pre-context grounding exists; if fast execution is forced, proceed only with explicit risk notes
 </Execution_Policy>
 
 <Steps>
+0. **Pre-context Intake (required before Phase 0 starts)**:
+   - Derive a task slug from the request.
+   - Load the latest relevant snapshot from `.omx/context/{slug}-*.md` when available.
+   - If no snapshot exists, create `.omx/context/{slug}-{timestamp}.md` (UTC `YYYYMMDDTHHMMSSZ`) with:
+     - Task statement
+     - Desired outcome
+     - Known facts/evidence
+     - Constraints
+     - Unknowns/open questions
+     - Likely codebase touchpoints
+   - If ambiguity remains high, run `explore` first for brownfield facts, then run `$deep-interview --quick <task>` before proceeding.
+   - Carry the snapshot path into autopilot artifacts/state so all phases share grounded context.
+
 1. **Phase 0 - Expansion**: Turn the user's idea into a detailed spec
+   - If `.omx/specs/deep-interview-*.md` exists for this task: reuse it and skip redundant expansion work
+   - If prompt is highly vague: route to `$deep-interview` for Socratic ambiguity-gated clarification
    - Analyst (Opus): Extract requirements
    - Architect (Opus): Create technical specification
    - Output: `.omx/plans/autopilot-spec.md`
@@ -84,7 +102,7 @@ Most non-trivial software tasks require coordinated phases: understanding requir
 Use `omx_state` MCP tools for autopilot lifecycle state.
 
 - **On start**:
-  `state_write({mode: "autopilot", active: true, current_phase: "expansion", started_at: "<now>"})`
+  `state_write({mode: "autopilot", active: true, current_phase: "expansion", started_at: "<now>", state: {context_snapshot_path: "<snapshot-path>"}})`
 - **On phase transitions**:
   `state_write({mode: "autopilot", current_phase: "planning"})`
   `state_write({mode: "autopilot", current_phase: "execution"})`
@@ -121,7 +139,7 @@ Why bad: This is an exploration/brainstorming request. Respond conversationally
 - Stop and report when the same QA error persists across 3 cycles (fundamental issue requiring human input)
 - Stop and report when validation keeps failing after 3 re-validation rounds
 - Stop when the user says "stop", "cancel", or "abort"
-- If requirements were too vague and expansion produces an unclear spec, pause and ask the user for clarification before proceeding
+- If requirements were too vague and expansion produces an unclear spec, pause and redirect to `$deep-interview` before proceeding
 </Escalation_And_Stop_Conditions>
 
 <Final_Checklist>
@@ -153,6 +171,18 @@ skipValidation = false
 
 If autopilot was cancelled or failed, run `/autopilot` again to resume from where it stopped.
 
+## Recommended Clarity Pipeline
+
+For ambiguous requests, prefer:
+
+```
+deep-interview -> ralplan -> autopilot
+```
+
+- `deep-interview`: ambiguity-gated Socratic requirements
+- `ralplan`: consensus planning (planner/architect/critic)
+- `autopilot`: execution + QA + validation
+
 ## Best Practices for Input
 
 1. Be specific about the domain -- "bookstore" not "store"