oh-my-harness 0.2.1 → 0.3.0

package/README.md

@@ -241,7 +241,7 @@ rules:
     priority: 10
 
 enforcement:
-  preCommit: ["test", "lint", "build"]
+  preCommit: ["pnpm test", "npx eslint .", "npx tsc --noEmit"]
   blockedPaths: [".next/", "node_modules/"]
   blockedCommands: ["rm -rf", "sudo"]
   postSave:
@@ -290,6 +290,10 @@ oh-my-harness/
 │   │   ├── hooks.ts        # Executable hook scripts
 │   │   ├── settings.ts     # .claude/settings.json
 │   │   └── gitignore.ts    # .gitignore updater
+│   ├── detector/
+│   │   ├── project-detector.ts  # Deterministic project detection
+│   │   ├── types.ts             # ProjectFacts, Detector interface
+│   │   └── detectors/           # 14 language detectors
 │   ├── nl/
 │   │   ├── parse-intent.ts     # claude -p integration
 │   │   └── prompt-templates.ts # LLM prompt construction
@@ -301,7 +305,7 @@ oh-my-harness/
 │   ├── nextjs/
 │   ├── fastapi/
 │   └── nextjs-fastapi/
-└── tests/                  # 219 tests (unit + integration)
+└── tests/                  # 422 tests (unit + integration)
 ```
 
 ---
@@ -354,6 +358,7 @@ No code changes required. The registry auto-discovers it.
 - [x] `npx oh-my-harness` — zero-install usage
 - [x] `oh-my-harness sync` — regenerate from harness.yaml
 - [x] Building block catalog — 10 verified hook templates
+- [x] Project detector — 14 language auto-detection for accurate NL generation
 - [ ] Cursor (`.cursor/rules/`) emitter
 - [ ] Codex (`AGENTS.md`) emitter
 - [ ] GitHub Copilot emitter

package/dist/cli/commands/init.js

@@ -5,6 +5,7 @@ import { PresetRegistry } from "../../core/preset-registry.js";
 import { mergePresets } from "../../core/config-merger.js";
 import { generate } from "../../core/generator.js";
 import { generateHarnessConfig } from "../../nl/parse-intent.js";
+import { detectProject } from "../../detector/project-detector.js";
 import { harnessToMergedConfigV2 } from "../../core/harness-converter-v2.js";
 import { createDefaultRegistry } from "../../catalog/registry.js";
 function getDefaultPresetsDir() {
@@ -107,6 +108,14 @@ async function initWithNL(projectDir, presetsDir, options) {
         return;
     }
     console.log(`Generating harness config for: "${description}"`);
+    // Detect project facts for richer prompt context
+    let facts;
+    try {
+        facts = await detectProject(projectDir);
+    }
+    catch {
+        // Non-fatal: continue with no facts
+    }
     // Load catalog blocks so LLM knows available building blocks
     const registry = await createDefaultRegistry();
     const catalogBlocks = registry.list().map((b) => ({
@@ -117,7 +126,7 @@ async function initWithNL(projectDir, presetsDir, options) {
         matcher: b.matcher,
         params: b.params.map((p) => ({ name: p.name, type: p.type, description: p.description, required: p.required, default: p.default })),
     }));
-    const harness = await generateHarnessConfig(description, options.nlRunner, catalogBlocks);
+    const harness = await generateHarnessConfig(description, options.nlRunner, catalogBlocks, facts);
     // Show summary
     const stackNames = harness.project.stacks.map((s) => `${s.name} (${s.framework})`).join(", ");
     console.log(`\nStacks: ${stackNames}`);

package/dist/cli/tool-checker.d.ts

@@ -6,10 +6,10 @@ export interface ToolCheck {
     installCmd: string;
     installed: boolean;
 }
-interface ToolRef {
+export interface ToolRef {
     name: string;
     source: string;
+    lookupCommand: string;
 }
 export declare function extractToolNames(config: HarnessConfig): ToolRef[];
 export declare function checkReferencedTools(config: HarnessConfig): Promise<ToolCheck[]>;
-export {};

package/dist/cli/tool-checker.js

@@ -17,27 +17,66 @@ function extractBinary(command) {
     const trimmed = command.trim();
     if (!trimmed)
         return undefined;
-    return trimmed.split(/\s+/)[0];
+    const parts = trimmed.split(/\s+/);
+    // Skip gradle wrapper commands (managed by project)
+    if (parts[0] === "./gradlew" || parts[0] === "gradlew")
+        return undefined;
+    // npx [options] <tool> ... → skip option flags, extract first non-option token
+    if (parts[0] === "npx") {
+        let i = 1;
+        while (i < parts.length && parts[i].startsWith("-")) {
+            if (parts[i] === "-p" || parts[i] === "--package")
+                i += 2;
+            else
+                i += 1;
+        }
+        return i < parts.length ? { name: parts[i], lookupCommand: "npx" } : undefined;
+    }
+    // npm exec <tool> → extract tool; other npm subcommands → skip
+    if (parts[0] === "npm") {
+        if (parts[1] === "exec" && parts.length > 2)
+            return { name: parts[2], lookupCommand: "npm" };
+        return undefined;
+    }
+    // pnpm exec <tool> → wrapper lookup; pnpm dlx <tool> → direct lookup
+    if (parts[0] === "pnpm") {
+        if (parts[1] === "exec" && parts.length > 2)
+            return { name: parts[2], lookupCommand: "pnpm" };
+        if (parts[1] === "dlx" && parts.length > 2)
+            return { name: parts[2], lookupCommand: "pnpm" };
+        return undefined;
+    }
+    // yarn dlx <tool> → direct lookup
+    if (parts[0] === "yarn") {
+        if (parts[1] === "dlx" && parts.length > 2)
+            return { name: parts[2], lookupCommand: "yarn" };
+        return undefined;
+    }
+    // poetry run <tool> → check poetry existence
+    if (parts[0] === "poetry" && parts[1] === "run" && parts.length > 2) {
+        return { name: parts[2], lookupCommand: "poetry" };
+    }
+    return { name: parts[0], lookupCommand: parts[0] };
 }
 export function extractToolNames(config) {
     const seen = new Set();
     const tools = [];
     for (const cmd of config.enforcement.preCommit) {
-        const name = extractBinary(cmd);
-        if (!name)
+        const result = extractBinary(cmd);
+        if (!result)
             continue;
-        if (!seen.has(name)) {
-            seen.add(name);
-            tools.push({ name, source: "pre-commit" });
+        if (!seen.has(result.name)) {
+            seen.add(result.name);
+            tools.push({ name: result.name, lookupCommand: result.lookupCommand, source: "pre-commit" });
         }
     }
     for (const ps of config.enforcement.postSave) {
-        const name = extractBinary(ps.command);
-        if (!name)
+        const result = extractBinary(ps.command);
+        if (!result)
             continue;
-        if (!seen.has(name)) {
-            seen.add(name);
-            tools.push({ name, source: "post-save hook" });
+        if (!seen.has(result.name)) {
+            seen.add(result.name);
+            tools.push({ name: result.name, lookupCommand: result.lookupCommand, source: "post-save hook" });
         }
     }
     return tools;
@@ -58,7 +97,7 @@ export async function checkReferencedTools(config) {
     const refs = extractToolNames(config);
     const results = [];
     for (const ref of refs) {
-        const installed = await commandExists(ref.name);
+        const installed = await commandExists(ref.lookupCommand);
         results.push({
             name: ref.name,
             command: ref.name,

package/dist/cli/tui/init-flow.d.ts

@@ -1,7 +1,9 @@
 import type { DepCheck } from "../deps-checker.js";
 import type { HarnessConfig } from "../../core/harness-schema.js";
+import type { ProjectFacts } from "../../detector/types.js";
 export declare function formatDepResults(deps: DepCheck[]): string;
 export declare function formatConfigSummary(config: HarnessConfig): string;
+export declare function formatProjectFacts(facts: ProjectFacts): string;
 export declare function runInitTUI(options?: {
     projectDir?: string;
     presetsDir?: string;

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

@@ -12,6 +12,7 @@ import { generate } from "../../core/generator.js";
 import { generateHarnessConfig } from "../../nl/parse-intent.js";
 import { harnessToMergedConfig } from "../../core/harness-converter.js";
 import { HarnessConfigSchema } from "../../core/harness-schema.js";
+import { detectProject } from "../../detector/project-detector.js";
 function getDefaultPresetsDir() {
     return path.resolve(import.meta.dirname, "../../../presets");
 }
@@ -79,6 +80,25 @@ export function formatConfigSummary(config) {
     }
     return lines.join("\n");
 }
+export function formatProjectFacts(facts) {
+    const lines = [];
+    const entries = [
+        ["Languages", facts.languages],
+        ["Frameworks", facts.frameworks],
+        ["Package managers", facts.packageManagers],
+        ["Test commands", facts.testCommands],
+        ["Lint commands", facts.lintCommands],
+        ["Build commands", facts.buildCommands],
+        ["Typecheck", facts.typecheckCommands],
+        ["Blocked paths", facts.blockedPaths],
+    ];
+    for (const [label, values] of entries) {
+        if (values.length > 0) {
+            lines.push(`  ${chalk.bold(label)}: ${values.join(", ")}`);
+        }
+    }
+    return lines.length > 0 ? lines.join("\n") : `  ${chalk.dim("No project signals detected")}`;
+}
 function handleCancel(value) {
     if (p.isCancel(value)) {
         p.cancel("Operation cancelled.");
@@ -114,6 +134,24 @@ export async function runInitTUI(options) {
     if (!claudeInstalled) {
         p.log.warn("claude CLI not installed. AI-powered mode will not be available.");
     }
+    // Step 2.5: Project Detection
+    const detectSpinner = p.spinner();
+    detectSpinner.start("Detecting project type...");
+    let projectFacts;
+    try {
+        const facts = await detectProject(projectDir);
+        const hasAnyFacts = facts.languages.length > 0 || facts.frameworks.length > 0;
+        if (hasAnyFacts) {
+            projectFacts = facts;
+        }
+        detectSpinner.stop("Project detected");
+    }
+    catch {
+        detectSpinner.stop("Project detection skipped");
+    }
+    if (projectFacts) {
+        p.note(formatProjectFacts(projectFacts), "Detected Project");
+    }
     const modeOptions = [];
     if (claudeInstalled) {
         modeOptions.push({
@@ -163,7 +201,7 @@ export async function runInitTUI(options) {
         const genSpinner = p.spinner();
         genSpinner.start("Generating harness configuration...");
         try {
-            harnessConfig = await generateHarnessConfig(description);
+            harnessConfig = await generateHarnessConfig(description, undefined, undefined, projectFacts);
             genSpinner.stop("Configuration generated");
         }
         catch (err) {

package/dist/core/harness-schema.d.ts

@@ -80,16 +80,16 @@ export declare const HarnessConfigSchema: z.ZodObject<{
             pattern: string;
         }>, "many">>;
     }, "strip", z.ZodTypeAny, {
-        preCommit: string[];
         blockedPaths: string[];
+        preCommit: string[];
         blockedCommands: string[];
         postSave: {
             command: string;
             pattern: string;
         }[];
     }, {
-        preCommit?: string[] | undefined;
         blockedPaths?: string[] | undefined;
+        preCommit?: string[] | undefined;
         blockedCommands?: string[] | undefined;
         postSave?: {
             command: string;
@@ -145,8 +145,8 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         priority: number;
     }[];
     enforcement: {
-        preCommit: string[];
         blockedPaths: string[];
+        preCommit: string[];
         blockedCommands: string[];
         postSave: {
             command: string;
@@ -173,8 +173,8 @@ export declare const HarnessConfigSchema: z.ZodObject<{
         priority?: number | undefined;
     }[];
     enforcement: {
-        preCommit?: string[] | undefined;
         blockedPaths?: string[] | undefined;
+        preCommit?: string[] | undefined;
         blockedCommands?: string[] | undefined;
         postSave?: {
             command: string;

package/dist/detector/detectors/cpp.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const cppDetector: Detector;

package/dist/detector/detectors/cpp.js

@@ -0,0 +1,44 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export const cppDetector = {
+    name: "cpp",
+    detect: async (projectDir) => {
+        const cmakeFile = path.join(projectDir, "CMakeLists.txt");
+        const makeFile = path.join(projectDir, "Makefile");
+        const mesonFile = path.join(projectDir, "meson.build");
+        const [hasCMake, hasMakefile, hasMeson] = await Promise.all([
+            fs.access(cmakeFile).then(() => true).catch(() => false),
+            fs.access(makeFile).then(() => true).catch(() => false),
+            fs.access(mesonFile).then(() => true).catch(() => false),
+        ]);
+        const blockedPaths = ["build/", "cmake-build-*/"];
+        if (hasCMake) {
+            return {
+                languages: ["c", "cpp"],
+                buildCommands: ["cmake --build build"],
+                testCommands: ["ctest --test-dir build"],
+                blockedPaths,
+                detectedFiles: ["CMakeLists.txt"],
+            };
+        }
+        if (hasMeson) {
+            return {
+                languages: ["c", "cpp"],
+                buildCommands: ["meson compile -C build"],
+                testCommands: ["meson test -C build"],
+                blockedPaths,
+                detectedFiles: ["meson.build"],
+            };
+        }
+        if (hasMakefile) {
+            return {
+                languages: ["c"],
+                buildCommands: ["make"],
+                testCommands: ["make test"],
+                blockedPaths,
+                detectedFiles: ["Makefile"],
+            };
+        }
+        return {};
+    },
+};

package/dist/detector/detectors/dart.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const dartDetector: Detector;

package/dist/detector/detectors/dart.js

@@ -0,0 +1,44 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export const dartDetector = {
+    name: "dart",
+    detect: async (projectDir) => {
+        let entries;
+        try {
+            entries = await fs.readdir(projectDir);
+        }
+        catch {
+            return {};
+        }
+        if (!entries.includes("pubspec.yaml"))
+            return {};
+        let pubspecContent = "";
+        try {
+            pubspecContent = await fs.readFile(path.join(projectDir, "pubspec.yaml"), "utf-8");
+        }
+        catch {
+            return {};
+        }
+        const isFlutter = pubspecContent.includes("flutter:");
+        const languages = ["dart"];
+        const frameworks = [];
+        const packageManagers = [];
+        const testCommands = [];
+        const buildCommands = [];
+        const lintCommands = ["dart analyze"];
+        const blockedPaths = [".dart_tool/", "build/"];
+        const detectedFiles = ["pubspec.yaml"];
+        if (isFlutter) {
+            frameworks.push("flutter");
+            packageManagers.push("flutter");
+            testCommands.push("flutter test");
+            buildCommands.push("flutter build");
+        }
+        else {
+            packageManagers.push("pub");
+            testCommands.push("dart test");
+            buildCommands.push("dart compile exe");
+        }
+        return { languages, frameworks, packageManagers, testCommands, buildCommands, lintCommands, blockedPaths, detectedFiles };
+    },
+};

package/dist/detector/detectors/dotnet.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const dotnetDetector: Detector;

package/dist/detector/detectors/dotnet.js

@@ -0,0 +1,43 @@
+import * as fs from "fs/promises";
+export const dotnetDetector = {
+    name: "dotnet",
+    detect: async (projectDir) => {
+        let entries;
+        try {
+            entries = await fs.readdir(projectDir);
+        }
+        catch {
+            return {};
+        }
+        const sorted = [...entries].sort();
+        const csprojFiles = sorted.filter((e) => e.endsWith(".csproj"));
+        const fsprojFiles = sorted.filter((e) => e.endsWith(".fsproj"));
+        const slnFiles = sorted.filter((e) => e.endsWith(".sln"));
+        if (!csprojFiles.length && !fsprojFiles.length && !slnFiles.length) {
+            return {};
+        }
+        const detectedFiles = [];
+        const languages = [];
+        if (csprojFiles.length > 0) {
+            detectedFiles.push(...csprojFiles);
+            languages.push("csharp");
+        }
+        if (fsprojFiles.length > 0) {
+            detectedFiles.push(...fsprojFiles);
+            languages.push("fsharp");
+        }
+        if (slnFiles.length > 0) {
+            detectedFiles.push(...slnFiles);
+        }
+        return {
+            ...(languages.length > 0 ? { languages } : {}),
+            frameworks: ["dotnet"],
+            packageManagers: ["nuget"],
+            buildCommands: ["dotnet build"],
+            testCommands: ["dotnet test"],
+            lintCommands: ["dotnet format"],
+            blockedPaths: ["bin/", "obj/"],
+            detectedFiles,
+        };
+    },
+};

package/dist/detector/detectors/elixir.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const elixirDetector: Detector;

package/dist/detector/detectors/elixir.js

@@ -0,0 +1,22 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export const elixirDetector = {
+    name: "elixir",
+    detect: async (projectDir) => {
+        try {
+            await fs.access(path.join(projectDir, "mix.exs"));
+        }
+        catch {
+            return {};
+        }
+        return {
+            languages: ["elixir"],
+            packageManagers: ["mix"],
+            testCommands: ["mix test"],
+            lintCommands: ["mix credo"],
+            buildCommands: ["mix compile"],
+            blockedPaths: ["_build/", "deps/"],
+            detectedFiles: ["mix.exs"],
+        };
+    },
+};

package/dist/detector/detectors/go.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const goDetector: Detector;

package/dist/detector/detectors/go.js

@@ -0,0 +1,22 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export const goDetector = {
+    name: "go",
+    detect: async (projectDir) => {
+        try {
+            await fs.access(path.join(projectDir, "go.mod"));
+        }
+        catch {
+            return {};
+        }
+        return {
+            languages: ["go"],
+            packageManagers: ["go modules"],
+            testCommands: ["go test ./..."],
+            lintCommands: ["golangci-lint run"],
+            buildCommands: ["go build ./..."],
+            blockedPaths: ["vendor/"],
+            detectedFiles: ["go.mod"],
+        };
+    },
+};

package/dist/detector/detectors/index.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const allDetectors: Detector[];

package/dist/detector/detectors/index.js

@@ -0,0 +1,30 @@
+import { nodeDetector } from "./node.js";
+import { pythonDetector } from "./python.js";
+import { swiftDetector } from "./swift.js";
+import { goDetector } from "./go.js";
+import { rustDetector } from "./rust.js";
+import { javaDetector } from "./java.js";
+import { cppDetector } from "./cpp.js";
+import { dotnetDetector } from "./dotnet.js";
+import { phpDetector } from "./php.js";
+import { rubyDetector } from "./ruby.js";
+import { dartDetector } from "./dart.js";
+import { elixirDetector } from "./elixir.js";
+import { scalaDetector } from "./scala.js";
+import { zigDetector } from "./zig.js";
+export const allDetectors = [
+    nodeDetector,
+    pythonDetector,
+    swiftDetector,
+    goDetector,
+    rustDetector,
+    javaDetector,
+    cppDetector,
+    dotnetDetector,
+    phpDetector,
+    rubyDetector,
+    dartDetector,
+    elixirDetector,
+    scalaDetector,
+    zigDetector,
+];

package/dist/detector/detectors/java.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const javaDetector: Detector;

package/dist/detector/detectors/java.js

@@ -0,0 +1,59 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export const javaDetector = {
+    name: "java",
+    detect: async (projectDir) => {
+        const pomPath = path.join(projectDir, "pom.xml");
+        const gradlePath = path.join(projectDir, "build.gradle");
+        const gradleKtsPath = path.join(projectDir, "build.gradle.kts");
+        const gradlewPath = path.join(projectDir, "gradlew");
+        const [hasPom, hasGradle, hasGradleKts, hasGradlew] = await Promise.all([
+            fileExists(pomPath),
+            fileExists(gradlePath),
+            fileExists(gradleKtsPath),
+            fileExists(gradlewPath),
+        ]);
+        if (hasPom) {
+            return {
+                languages: ["java"],
+                packageManagers: ["maven"],
+                testCommands: ["mvn test"],
+                buildCommands: ["mvn compile"],
+                blockedPaths: ["target/"],
+                detectedFiles: ["pom.xml"],
+            };
+        }
+        const gradleCmd = hasGradlew ? "./gradlew" : "gradle";
+        const gradlewFiles = hasGradlew ? ["gradlew"] : [];
+        if (hasGradleKts) {
+            return {
+                languages: ["java", "kotlin"],
+                packageManagers: ["gradle"],
+                testCommands: [`${gradleCmd} test`],
+                buildCommands: [`${gradleCmd} build`],
+                blockedPaths: ["build/", ".gradle/"],
+                detectedFiles: ["build.gradle.kts", ...gradlewFiles],
+            };
+        }
+        if (hasGradle) {
+            return {
+                languages: ["java"],
+                packageManagers: ["gradle"],
+                testCommands: [`${gradleCmd} test`],
+                buildCommands: [`${gradleCmd} build`],
+                blockedPaths: ["build/", ".gradle/"],
+                detectedFiles: ["build.gradle", ...gradlewFiles],
+            };
+        }
+        return {};
+    },
+};

package/dist/detector/detectors/node.d.ts

@@ -0,0 +1,2 @@
+import type { Detector } from "../types.js";
+export declare const nodeDetector: Detector;