oh-my-harness 0.8.0 → 0.9.0

package/dist/catalog/blocks/tdd-guard.js

@@ -72,8 +72,11 @@ fi
 
 # edit-history에서 테스트 파일 검색
 if jq -e --arg b "\$BASENAME" '.edits[] | select(contains($b) and (contains(".test.") or contains(".spec.") or contains("test_")))' "\$HISTORY_FILE" >/dev/null 2>&1; then
-  # 테스트 먼저 수정됨 → 소스 기록 + 통과
-  UPDATED=$(jq --arg f "\$FILE_PATH" '.edits += [$f] | .edits |= unique' "\$HISTORY_FILE" 2>/dev/null) || true
+  # 테스트 먼저 수정됨 → 매칭 테스트 기록 소비(제거) + 소스 기록 + 통과
+  UPDATED=$(jq --arg b "\$BASENAME" --arg f "\$FILE_PATH" '
+    .edits |= [.[] | select((contains($b) and (contains(".test.") or contains(".spec.") or contains("test_"))) | not)]
+    | .edits += [$f] | .edits |= unique
+  ' "\$HISTORY_FILE" 2>/dev/null) || true
   if [[ -n "\$UPDATED" ]]; then
     echo "\$UPDATED" > "\$HISTORY_FILE"
   fi

package/dist/cli/tui/init-flow.js

@@ -9,7 +9,9 @@ import { PresetRegistry } from "../../core/preset-registry.js";
 import { loadAndMergePresets, writeHarnessState } from "../commands/init.js";
 import { mergePresets } from "../../core/config-merger.js";
 import { generate } from "../../core/generator.js";
-import { generateHarnessConfig } from "../../nl/parse-intent.js";
+import { generateHarnessConfig, createDefaultRunner } from "../../nl/parse-intent.js";
+import { hasProviderConfig } from "../../nl/config-store.js";
+import { runProviderSetup } from "./provider-setup.js";
 import { mergeEnforcementAndHooks } from "../../core/harness-converter.js";
 import { HarnessConfigSchema } from "../../core/harness-schema.js";
 import { detectProject } from "../../detector/project-detector.js";
@@ -187,7 +189,17 @@ export async function runInitTUI(options) {
     let harnessConfig;
     let presetNames;
     if (mode === "nl") {
-        // Step 4a: NL Mode
+        // Step 4a: NL Mode — check provider config
+        const hasConfig = await hasProviderConfig();
+        if (!hasConfig) {
+            p.log.info("No AI provider configured yet. Let's set one up.");
+            const providerConfig = await runProviderSetup();
+            if (!providerConfig) {
+                p.cancel("Provider setup cancelled. Use preset mode instead.");
+                process.exit(0);
+            }
+        }
+        const runner = await createDefaultRunner();
         const description = await p.text({
             message: "Describe your project:",
             placeholder: "e.g., Next.js e-commerce app with Stripe and Tailwind",
@@ -208,7 +220,7 @@ export async function runInitTUI(options) {
                 description: b.description,
                 params: b.params.map((pp) => ({ name: pp.name, required: pp.required, default: pp.default, description: pp.description })),
             }));
-            harnessConfig = await generateHarnessConfig(description, undefined, catalogBlocks, projectFacts);
+            harnessConfig = await generateHarnessConfig(description, runner, catalogBlocks, projectFacts);
             genSpinner.stop("Configuration generated");
         }
         catch (err) {

package/dist/cli/tui/provider-setup.d.ts

@@ -0,0 +1,2 @@
+import { type ProviderConfig } from "../../nl/config-store.js";
+export declare function runProviderSetup(): Promise<ProviderConfig | undefined>;

package/dist/cli/tui/provider-setup.js

@@ -0,0 +1,85 @@
+import * as p from "@clack/prompts";
+import { getAvailableProviders, getProviderDefinition, } from "../../nl/provider-registry.js";
+import { saveProviderConfig, } from "../../nl/config-store.js";
+export async function runProviderSetup() {
+    p.intro("AI Provider Setup");
+    const providers = getAvailableProviders();
+    // Step 1: Select provider
+    const providerName = await p.select({
+        message: "Select AI provider for natural language mode:",
+        options: providers.map((prov) => ({
+            value: prov.name,
+            label: prov.displayName,
+        })),
+    });
+    if (p.isCancel(providerName)) {
+        p.cancel("Provider setup cancelled.");
+        return undefined;
+    }
+    const def = getProviderDefinition(providerName);
+    // Step 2: Select method (CLI or API)
+    let method;
+    if (def.supportsCli && def.supportsApi) {
+        const selected = await p.select({
+            message: "How would you like to connect?",
+            options: [
+                { value: "cli", label: `CLI tool (${def.cliCommand ?? def.name})` },
+                { value: "api", label: "API Key" },
+            ],
+        });
+        if (p.isCancel(selected)) {
+            p.cancel("Provider setup cancelled.");
+            return undefined;
+        }
+        method = selected;
+    }
+    else if (def.supportsCli) {
+        method = "cli";
+    }
+    else {
+        method = "api";
+    }
+    const config = {
+        provider: providerName,
+        method,
+    };
+    // Step 3: Get API key if needed
+    if (method === "api") {
+        const apiKey = await p.text({
+            message: `Enter your ${def.displayName} API key:`,
+            placeholder: "sk-...",
+            validate: (value) => {
+                if (!value || !value.trim())
+                    return "API key is required";
+                return undefined;
+            },
+        });
+        if (p.isCancel(apiKey)) {
+            p.cancel("Provider setup cancelled.");
+            return undefined;
+        }
+        config.apiKey = apiKey;
+        // Select model from available list
+        const selectedModel = await p.select({
+            message: "Select model:",
+            options: def.availableModels.map((m) => ({
+                value: m.id,
+                label: m.label,
+                hint: m.id === def.defaultModel ? "default" : undefined,
+            })),
+            initialValue: def.defaultModel,
+        });
+        if (p.isCancel(selectedModel)) {
+            p.cancel("Provider setup cancelled.");
+            return undefined;
+        }
+        config.model = selectedModel;
+    }
+    else {
+        config.cliCommand = def.cliCommand ?? def.name;
+    }
+    // Save config
+    await saveProviderConfig(config);
+    p.log.success(`Provider saved: ${def.displayName} (${method})`);
+    return config;
+}

package/dist/detector/detectors/node.js

@@ -165,7 +165,7 @@ export const nodeDetector = {
         const tsconfigPath = path.join(projectDir, "tsconfig.json");
         if (await fileExists(tsconfigPath)) {
             languages.push("typescript");
-            typecheckCommands.push("tsc --noEmit");
+            typecheckCommands.push("npx tsc --noEmit");
             detectedFiles.push("tsconfig.json");
         }
         else {

package/dist/nl/config-store.d.ts

@@ -0,0 +1,11 @@
+export interface ProviderConfig {
+    provider: "claude" | "openai" | "gemini";
+    method: "cli" | "api";
+    apiKey?: string;
+    model?: string;
+    cliCommand?: string;
+}
+export declare function getConfigDir(): string;
+export declare function hasProviderConfig(): Promise<boolean>;
+export declare function loadProviderConfig(): Promise<ProviderConfig | undefined>;
+export declare function saveProviderConfig(config: ProviderConfig): Promise<void>;

package/dist/nl/config-store.js

@@ -0,0 +1,33 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+export function getConfigDir() {
+    const home = process.env.HOME ?? os.homedir();
+    return path.join(home, ".omh");
+}
+function getConfigPath() {
+    return path.join(getConfigDir(), "config.json");
+}
+export async function hasProviderConfig() {
+    try {
+        await fs.access(getConfigPath());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function loadProviderConfig() {
+    try {
+        const raw = await fs.readFile(getConfigPath(), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function saveProviderConfig(config) {
+    const dir = getConfigDir();
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}

package/dist/nl/parse-intent.d.ts

@@ -6,7 +6,13 @@ export interface ParsedIntent {
     confidence: number;
     explanation: string;
 }
-export type ClaudeRunner = (prompt: string) => Promise<string>;
-export declare const defaultClaudeRunner: ClaudeRunner;
+/** Generic LLM runner type — takes a prompt and returns a response string */
+export type LLMRunner = (prompt: string) => Promise<string>;
+/** @deprecated Use LLMRunner instead. Kept for backward compatibility. */
+export type ClaudeRunner = LLMRunner;
+/** Creates a runner from the saved provider config (~/.omh/config.json) or falls back to claude CLI */
+export declare function createDefaultRunner(): Promise<LLMRunner>;
+/** Legacy default runner using claude CLI directly */
+export declare const defaultClaudeRunner: LLMRunner;
 export declare function parseNaturalLanguage(description: string, availablePresets: PresetInfo[], runner?: ClaudeRunner): Promise<ParsedIntent>;
 export declare function generateHarnessConfig(description: string, runner?: ClaudeRunner, catalogBlocks?: CatalogBlockInfo[], projectFacts?: ProjectFacts): Promise<HarnessConfig>;

package/dist/nl/parse-intent.js

@@ -1,37 +1,24 @@
-import { spawn } from "node:child_process";
 import yaml from "js-yaml";
 import { buildPresetSelectionPrompt, buildHarnessGenerationPrompt } from "./prompt-templates.js";
 import { HarnessConfigSchema } from "../core/harness-schema.js";
+import { loadProviderConfig } from "./config-store.js";
+import { createProvider } from "./provider-registry.js";
+import { createClaudeCliProvider } from "./providers/claude-cli.js";
+/** Creates a runner from the saved provider config (~/.omh/config.json) or falls back to claude CLI */
+export async function createDefaultRunner() {
+    const config = await loadProviderConfig();
+    if (config) {
+        const provider = createProvider(config);
+        return (prompt) => provider.run(prompt);
+    }
+    // Fallback: claude CLI
+    const cliProvider = createClaudeCliProvider("claude");
+    return (prompt) => cliProvider.run(prompt);
+}
+/** Legacy default runner using claude CLI directly */
 export const defaultClaudeRunner = async (prompt) => {
-    return new Promise((resolve, reject) => {
-        const proc = spawn("claude", ["-p", "-"], {
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env },
-        });
-        let stdout = "";
-        let stderr = "";
-        proc.stdout.on("data", (data) => { stdout += data.toString(); });
-        proc.stderr.on("data", (data) => { stderr += data.toString(); });
-        proc.on("error", (err) => {
-            if (err.code === "ENOENT") {
-                reject(new Error("claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code"));
-            }
-            else {
-                reject(err);
-            }
-        });
-        proc.on("close", (code) => {
-            if (code === 0) {
-                resolve(stdout);
-            }
-            else {
-                reject(new Error(`claude exited with code ${code}: ${stderr || stdout}`));
-            }
-        });
-        // Write prompt to stdin and close
-        proc.stdin.write(prompt);
-        proc.stdin.end();
-    });
+    const cliProvider = createClaudeCliProvider("claude");
+    return cliProvider.run(prompt);
 };
 function extractJson(text) {
     // Try to extract a JSON object from text that may contain extra content

package/dist/nl/provider-registry.d.ts

@@ -0,0 +1,22 @@
+import type { ProviderConfig } from "./config-store.js";
+export interface LLMProvider {
+    name: string;
+    run(prompt: string): Promise<string>;
+}
+export interface ModelEntry {
+    id: string;
+    label: string;
+}
+export interface ProviderDefinition {
+    name: string;
+    displayName: string;
+    supportsCli: boolean;
+    supportsApi: boolean;
+    defaultModel: string;
+    availableModels: ModelEntry[];
+    cliCommand?: string;
+}
+export declare function getAvailableProviders(): ProviderDefinition[];
+export declare function getProviderDefinition(name: string): ProviderDefinition | undefined;
+export declare function getAvailableModels(providerName: string): ModelEntry[];
+export declare function createProvider(config: ProviderConfig): LLMProvider;

package/dist/nl/provider-registry.js

@@ -0,0 +1,90 @@
+import { createClaudeCliProvider } from "./providers/claude-cli.js";
+import { createClaudeApiProvider } from "./providers/claude-api.js";
+import { createOpenaiApiProvider } from "./providers/openai-api.js";
+import { createGeminiApiProvider } from "./providers/gemini-api.js";
+const providers = [
+    {
+        name: "claude",
+        displayName: "Claude (Anthropic)",
+        supportsCli: true,
+        supportsApi: true,
+        defaultModel: "claude-sonnet-4-6",
+        availableModels: [
+            { id: "claude-opus-4-6", label: "Claude Opus 4.6 — most capable, 1M context" },
+            { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 — balanced, 1M context" },
+            { id: "claude-haiku-4-5", label: "Claude Haiku 4.5 — fastest, 200k context" },
+        ],
+        cliCommand: "claude",
+    },
+    {
+        name: "openai",
+        displayName: "OpenAI (GPT-5.4)",
+        supportsCli: false,
+        supportsApi: true,
+        defaultModel: "gpt-5.4",
+        availableModels: [
+            { id: "gpt-5.4", label: "GPT-5.4 — flagship, agentic & coding" },
+            { id: "gpt-5.4-mini", label: "GPT-5.4 Mini — strongest mini model" },
+            { id: "gpt-5.4-nano", label: "GPT-5.4 Nano — cheapest GPT-5.4 class" },
+            { id: "gpt-4.1", label: "GPT-4.1 — best non-reasoning, coding" },
+            { id: "gpt-4.1-mini", label: "GPT-4.1 Mini — balanced speed/cost" },
+            { id: "o3", label: "o3 — complex reasoning, math, science" },
+            { id: "o4-mini", label: "o4-mini — fast reasoning" },
+        ],
+    },
+    {
+        name: "gemini",
+        displayName: "Gemini (Google)",
+        supportsCli: false,
+        supportsApi: true,
+        defaultModel: "gemini-2.5-pro",
+        availableModels: [
+            { id: "gemini-2.5-pro", label: "Gemini 2.5 Pro — most advanced stable" },
+            { id: "gemini-2.5-flash", label: "Gemini 2.5 Flash — fastest stable" },
+            { id: "gemini-2.5-flash-lite", label: "Gemini 2.5 Flash Lite — most cost-effective" },
+            { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro Preview — cutting-edge (preview)" },
+            { id: "gemini-3-flash-preview", label: "Gemini 3 Flash Preview — frontier performance (preview)" },
+        ],
+    },
+];
+export function getAvailableProviders() {
+    return [...providers];
+}
+export function getProviderDefinition(name) {
+    return providers.find((p) => p.name === name);
+}
+export function getAvailableModels(providerName) {
+    const def = providers.find((p) => p.name === providerName);
+    return def ? [...def.availableModels] : [];
+}
+export function createProvider(config) {
+    const def = getProviderDefinition(config.provider);
+    if (!def) {
+        throw new Error(`Unknown AI provider: "${config.provider}". Available: ${providers.map((p) => p.name).join(", ")}`);
+    }
+    if (config.method !== "cli" && config.method !== "api") {
+        throw new Error(`Unsupported provider method: "${String(config.method)}"`);
+    }
+    if (config.method === "cli") {
+        if (config.provider === "claude") {
+            return createClaudeCliProvider(config.cliCommand ?? "claude");
+        }
+        throw new Error(`Provider "${config.provider}" does not support CLI mode`);
+    }
+    // API mode
+    const apiKey = config.apiKey?.trim();
+    if (!apiKey) {
+        throw new Error(`API key is required for "${config.provider}" API mode`);
+    }
+    const model = config.model?.trim() || def.defaultModel;
+    switch (config.provider) {
+        case "claude":
+            return createClaudeApiProvider(apiKey, model);
+        case "openai":
+            return createOpenaiApiProvider(apiKey, model);
+        case "gemini":
+            return createGeminiApiProvider(apiKey, model);
+        default:
+            throw new Error(`Unknown provider: "${config.provider}"`);
+    }
+}

package/dist/nl/providers/claude-api.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from "../provider-registry.js";
+export declare function createClaudeApiProvider(apiKey: string, model?: string): LLMProvider;

package/dist/nl/providers/claude-api.js

@@ -0,0 +1,42 @@
+const DEFAULT_MODEL = "claude-sonnet-4-20250514";
+const API_URL = "https://api.anthropic.com/v1/messages";
+const REQUEST_TIMEOUT_MS = 60_000;
+export function createClaudeApiProvider(apiKey, model = DEFAULT_MODEL) {
+    return {
+        name: "claude",
+        run: async (prompt) => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            let response;
+            try {
+                response = await fetch(API_URL, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-api-key": apiKey,
+                        "anthropic-version": "2023-06-01",
+                    },
+                    body: JSON.stringify({
+                        model,
+                        max_tokens: 4096,
+                        messages: [{ role: "user", content: prompt }],
+                    }),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (!response.ok) {
+                const errorBody = await response.text();
+                throw new Error(`Anthropic API error (${response.status}): ${errorBody}`);
+            }
+            const data = (await response.json());
+            const textBlock = data.content?.find((c) => c.type === "text");
+            if (!textBlock) {
+                throw new Error("Anthropic API returned no text content");
+            }
+            return textBlock.text;
+        },
+    };
+}

package/dist/nl/providers/claude-cli.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from "../provider-registry.js";
+export declare function createClaudeCliProvider(command?: string): LLMProvider;

package/dist/nl/providers/claude-cli.js

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+export function createClaudeCliProvider(command = "claude") {
+    return {
+        name: "claude",
+        run: async (prompt) => {
+            return new Promise((resolve, reject) => {
+                const proc = spawn(command, ["-p", "-"], {
+                    stdio: ["pipe", "pipe", "pipe"],
+                    env: { ...process.env },
+                });
+                let stdout = "";
+                let stderr = "";
+                proc.stdout.on("data", (data) => {
+                    stdout += data.toString();
+                });
+                proc.stderr.on("data", (data) => {
+                    stderr += data.toString();
+                });
+                proc.on("error", (err) => {
+                    if (err.code === "ENOENT") {
+                        reject(new Error(`${command} CLI not found. Install it with: npm install -g @anthropic-ai/claude-code`));
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                proc.on("close", (code) => {
+                    if (code === 0) {
+                        resolve(stdout.trim());
+                    }
+                    else {
+                        reject(new Error(`${command} exited with code ${code}: ${stderr || stdout}`));
+                    }
+                });
+                proc.stdin.write(prompt);
+                proc.stdin.end();
+            });
+        },
+    };
+}

package/dist/nl/providers/gemini-api.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from "../provider-registry.js";
+export declare function createGeminiApiProvider(apiKey: string, model?: string): LLMProvider;

package/dist/nl/providers/gemini-api.js

@@ -0,0 +1,44 @@
+const DEFAULT_MODEL = "gemini-2.5-flash";
+const REQUEST_TIMEOUT_MS = 60_000;
+function getApiUrl(model) {
+    return `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`;
+}
+export function createGeminiApiProvider(apiKey, model = DEFAULT_MODEL) {
+    return {
+        name: "gemini",
+        run: async (prompt) => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            let response;
+            try {
+                response = await fetch(getApiUrl(model), {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-goog-api-key": apiKey,
+                    },
+                    body: JSON.stringify({
+                        contents: [{ parts: [{ text: prompt }] }],
+                        generationConfig: {
+                            maxOutputTokens: 4096,
+                        },
+                    }),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (!response.ok) {
+                const errorBody = await response.text();
+                throw new Error(`Gemini API error (${response.status}): ${errorBody}`);
+            }
+            const data = (await response.json());
+            const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+            if (!text) {
+                throw new Error("Gemini API returned no content");
+            }
+            return text;
+        },
+    };
+}

package/dist/nl/providers/openai-api.d.ts

@@ -0,0 +1,2 @@
+import type { LLMProvider } from "../provider-registry.js";
+export declare function createOpenaiApiProvider(apiKey: string, model?: string): LLMProvider;

package/dist/nl/providers/openai-api.js

@@ -0,0 +1,41 @@
+const DEFAULT_MODEL = "gpt-5.4";
+const API_URL = "https://api.openai.com/v1/chat/completions";
+const REQUEST_TIMEOUT_MS = 60_000;
+export function createOpenaiApiProvider(apiKey, model = DEFAULT_MODEL) {
+    return {
+        name: "openai",
+        run: async (prompt) => {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+            let response;
+            try {
+                response = await fetch(API_URL, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "Authorization": `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model,
+                        messages: [{ role: "user", content: prompt }],
+                        max_completion_tokens: 4096,
+                    }),
+                    signal: controller.signal,
+                });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (!response.ok) {
+                const errorBody = await response.text();
+                throw new Error(`OpenAI API error (${response.status}): ${errorBody}`);
+            }
+            const data = (await response.json());
+            const content = data.choices?.[0]?.message?.content;
+            if (content == null) {
+                throw new Error("OpenAI API returned no content");
+            }
+            return content;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-harness",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Tame your AI coding agents with natural language",
   "type": "module",
   "bin": {