@kody-ade/kody-engine-lite 0.1.7 → 0.1.8

package/dist/bin/cli.js

@@ -109,11 +109,17 @@ function createClaudeCodeRunner() {
 }
 function createOpenCodeRunner() {
   return {
-    async run(stageName, prompt, _model, timeout, _taskDir, options) {
+    async run(stageName, prompt, model, timeout, _taskDir, options) {
+      const args2 = ["run"];
+      if (model) {
+        args2.push("--model", model);
+      }
+      args2.push(prompt);
       return runSubprocess(
         "opencode",
-        ["github", "run", "--agent", stageName],
-        prompt,
+        args2,
+        "",
+        // opencode takes message as positional, not stdin
         timeout,
         options
       );
@@ -892,8 +898,9 @@ async function executeAgentStage(ctx, def) {
   }
   const prompt = buildFullPrompt(def.name, ctx.taskId, ctx.taskDir, ctx.projectDir, ctx.input.feedback);
   const model = resolveModel(def.modelTier, def.name);
-  logger.info(`  model=${model} timeout=${def.timeout / 1e3}s`);
   const config = getProjectConfig();
+  const runnerName = config.agent.stageRunners?.[def.name] ?? config.agent.defaultRunner ?? Object.keys(ctx.runners)[0] ?? "claude";
+  logger.info(`  runner=${runnerName} model=${model} timeout=${def.timeout / 1e3}s`);
   const extraEnv = {};
   if (config.agent.litellmUrl) {
     extraEnv.ANTHROPIC_BASE_URL = config.agent.litellmUrl;
@@ -2004,6 +2011,235 @@ function detectArchitecture(cwd) {
   if (configs.length > 0) detected.push(`- Config files: ${configs.join(", ")}`);
   return detected;
 }
+function detectBasicConfig(cwd) {
+  let pm = "pnpm";
+  if (fs7.existsSync(path6.join(cwd, "yarn.lock"))) pm = "yarn";
+  else if (fs7.existsSync(path6.join(cwd, "bun.lockb"))) pm = "bun";
+  else if (!fs7.existsSync(path6.join(cwd, "pnpm-lock.yaml")) && fs7.existsSync(path6.join(cwd, "package-lock.json"))) pm = "npm";
+  let defaultBranch = "main";
+  try {
+    const ref = execFileSync7("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    defaultBranch = ref.replace("refs/remotes/origin/", "");
+  } catch {
+    try {
+      execFileSync7("git", ["rev-parse", "--verify", "origin/dev"], {
+        encoding: "utf-8",
+        timeout: 5e3,
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      defaultBranch = "dev";
+    } catch {
+    }
+  }
+  let owner = "";
+  let repo = "";
+  try {
+    const remote = execFileSync7("git", ["remote", "get-url", "origin"], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = remote.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+    if (match) {
+      owner = match[1];
+      repo = match[2];
+    }
+  } catch {
+  }
+  const hasOpenCode = fs7.existsSync(path6.join(cwd, "opencode.json"));
+  return { defaultBranch, owner, repo, pm, hasOpenCode };
+}
+function smartInit(cwd) {
+  const basic = detectBasicConfig(cwd);
+  let context = "";
+  const readIfExists = (rel, maxChars = 3e3) => {
+    const p = path6.join(cwd, rel);
+    if (fs7.existsSync(p)) {
+      const content = fs7.readFileSync(p, "utf-8");
+      return content.slice(0, maxChars);
+    }
+    return null;
+  };
+  const pkgJson = readIfExists("package.json");
+  if (pkgJson) context += `## package.json
+${pkgJson}
+
+`;
+  const tsconfig = readIfExists("tsconfig.json", 1e3);
+  if (tsconfig) context += `## tsconfig.json
+${tsconfig}
+
+`;
+  const readme = readIfExists("README.md", 2e3);
+  if (readme) context += `## README.md (first 2000 chars)
+${readme}
+
+`;
+  const claudeMd = readIfExists("CLAUDE.md", 3e3);
+  if (claudeMd) context += `## CLAUDE.md
+${claudeMd}
+
+`;
+  try {
+    const topDirs = fs7.readdirSync(cwd, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name);
+    context += `## Top-level directories
+${topDirs.join(", ")}
+
+`;
+    const srcDir = path6.join(cwd, "src");
+    if (fs7.existsSync(srcDir)) {
+      const srcDirs = fs7.readdirSync(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      context += `## src/ subdirectories
+${srcDirs.join(", ")}
+
+`;
+    }
+  } catch {
+  }
+  const existingFiles = [];
+  for (const f of [".env.example", "CLAUDE.md", ".ai-docs", "opencode.json", "vitest.config.ts", "vitest.config.mts", "jest.config.ts", "playwright.config.ts", ".eslintrc.js", "eslint.config.mjs", ".prettierrc"]) {
+    if (fs7.existsSync(path6.join(cwd, f))) existingFiles.push(f);
+  }
+  if (existingFiles.length) context += `## Config files present
+${existingFiles.join(", ")}
+
+`;
+  context += `## Detected: package manager=${basic.pm}, default branch=${basic.defaultBranch}, github=${basic.owner}/${basic.repo}, opencode=${basic.hasOpenCode}
+`;
+  const prompt = `You are analyzing a project to configure Kody (an autonomous SDLC pipeline).
+
+Given this project context, output ONLY a JSON object with EXACTLY this structure:
+
+{
+  "config": {
+    "quality": {
+      "typecheck": "${basic.pm} <script or command>",
+      "lint": "${basic.pm} <script or command>",
+      "lintFix": "${basic.pm} <script or command>",
+      "format": "${basic.pm} <script or command>",
+      "formatFix": "${basic.pm} <script or command>",
+      "testUnit": "${basic.pm} <script or command>"
+    },
+    "git": { "defaultBranch": "${basic.defaultBranch}" },
+    "github": { "owner": "${basic.owner}", "repo": "${basic.repo}" },
+    "paths": { "taskDir": ".tasks" },
+    "agent": {
+      "runner": "${basic.hasOpenCode ? "opencode" : "claude-code"}",
+      "defaultRunner": "${basic.hasOpenCode ? "opencode" : "claude"}",
+      "modelMap": { "cheap": "haiku", "mid": "sonnet", "strong": "opus" }
+    }
+  },
+  "architecture": "# Architecture\\n\\n<markdown content>",
+  "conventions": "# Conventions\\n\\n<markdown content>"
+}
+
+CRITICAL rules for config.quality:
+- Every command MUST start with "${basic.pm}" (e.g., "${basic.pm} typecheck", "${basic.pm} lint")
+- Look at the package.json "scripts" section to find the correct script names
+- testUnit must run ONLY unit tests \u2014 exclude integration and e2e tests. If there's a "test:unit" script use it. Otherwise use "test" but add exclude flags for int/e2e.
+- If a script doesn't exist and can't be inferred, set the value to ""
+- Do NOT invent commands that don't exist in package.json scripts
+
+Rules for architecture (markdown string):
+- Be specific about THIS project
+- Include: framework, language, database, testing, key directories, data flow
+- Reference CLAUDE.md and .ai-docs/ if they exist
+- Keep under 50 lines
+
+Rules for conventions (markdown string):
+- Extract actual patterns from the project
+- If CLAUDE.md exists, reference it
+- If .ai-docs/ exists, reference it
+- Keep under 30 lines
+
+Output ONLY valid JSON. No markdown fences. No explanation before or after.
+
+${context}`;
+  console.log("  \u23F3 Analyzing project with Claude Code...");
+  try {
+    const output = execFileSync7("claude", [
+      "--print",
+      "--model",
+      "haiku",
+      "--dangerously-skip-permissions",
+      prompt
+    ], {
+      encoding: "utf-8",
+      timeout: 12e4,
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const cleaned = output.replace(/^```json\s*\n?/m, "").replace(/\n?```\s*$/m, "");
+    const parsed = JSON.parse(cleaned);
+    const config = parsed.config ?? {};
+    if (!config.git) config.git = {};
+    if (!config.github) config.github = {};
+    if (!config.paths) config.paths = {};
+    if (!config.agent) config.agent = {};
+    config.git.defaultBranch = config.git.defaultBranch || basic.defaultBranch;
+    config.github.owner = config.github.owner || basic.owner;
+    config.github.repo = config.github.repo || basic.repo;
+    config.paths.taskDir = config.paths.taskDir || ".tasks";
+    config.agent.runner = config.agent.runner || (basic.hasOpenCode ? "opencode" : "claude-code");
+    config.agent.defaultRunner = config.agent.defaultRunner || (basic.hasOpenCode ? "opencode" : "claude");
+    if (!config.agent.modelMap) {
+      config.agent.modelMap = { cheap: "haiku", mid: "sonnet", strong: "opus" };
+    }
+    return {
+      config,
+      architecture: parsed.architecture ?? "",
+      conventions: parsed.conventions ?? ""
+    };
+  } catch (err) {
+    console.log("  \u26A0 Smart detection failed, falling back to basic detection");
+    return {
+      config: buildFallbackConfig(cwd, basic),
+      architecture: "",
+      conventions: ""
+    };
+  }
+}
+function buildFallbackConfig(cwd, basic) {
+  const pkg = (() => {
+    try {
+      return JSON.parse(fs7.readFileSync(path6.join(cwd, "package.json"), "utf-8"));
+    } catch {
+      return {};
+    }
+  })();
+  const scripts = pkg.scripts ?? {};
+  const find = (...c) => {
+    for (const s of c) {
+      if (scripts[s]) return `${basic.pm} ${s}`;
+    }
+    return "";
+  };
+  return {
+    quality: {
+      typecheck: find("typecheck", "type-check") || (pkg.devDependencies?.typescript ? `${basic.pm} tsc --noEmit` : ""),
+      lint: find("lint"),
+      lintFix: find("lint:fix", "lint-fix"),
+      format: find("format:check"),
+      formatFix: find("format", "format:fix"),
+      testUnit: find("test:unit", "test", "test:ci")
+    },
+    git: { defaultBranch: basic.defaultBranch },
+    github: { owner: basic.owner, repo: basic.repo },
+    paths: { taskDir: ".tasks" },
+    agent: {
+      runner: basic.hasOpenCode ? "opencode" : "claude-code",
+      defaultRunner: basic.hasOpenCode ? "opencode" : "claude",
+      modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
+    }
+  };
+}
 function initCommand(opts) {
   const cwd = process.cwd();
   console.log(`
@@ -2027,26 +2263,11 @@ function initCommand(opts) {
     console.log("  \u2713 .github/workflows/kody.yml");
   }
   const configDest = path6.join(cwd, "kody.config.json");
-  if (!fs7.existsSync(configDest)) {
-    const defaultConfig = {
-      quality: {
-        typecheck: "pnpm tsc --noEmit",
-        lint: "",
-        lintFix: "",
-        format: "",
-        formatFix: "",
-        testUnit: "pnpm test"
-      },
-      git: { defaultBranch: "main" },
-      github: { owner: "", repo: "" },
-      paths: { taskDir: ".tasks" },
-      agent: {
-        runner: "claude-code",
-        modelMap: { cheap: "haiku", mid: "sonnet", strong: "opus" }
-      }
-    };
-    fs7.writeFileSync(configDest, JSON.stringify(defaultConfig, null, 2) + "\n");
-    console.log("  \u2713 kody.config.json (created \u2014 edit github.owner and github.repo)");
+  let smartResult = null;
+  if (!fs7.existsSync(configDest) || opts.force) {
+    smartResult = smartInit(cwd);
+    fs7.writeFileSync(configDest, JSON.stringify(smartResult.config, null, 2) + "\n");
+    console.log("  \u2713 kody.config.json (auto-configured)");
   } else {
     console.log("  \u25CB kody.config.json (exists)");
   }
@@ -2172,33 +2393,38 @@ function initCommand(opts) {
       console.log("  \u2717 kody.config.json \u2014 invalid JSON");
     }
   }
-  console.log("\n\u2500\u2500 Architecture Detection \u2500\u2500");
+  console.log("\n\u2500\u2500 Project Memory \u2500\u2500");
   const memoryDir = path6.join(cwd, ".kody", "memory");
+  fs7.mkdirSync(memoryDir, { recursive: true });
   const archPath = path6.join(memoryDir, "architecture.md");
-  if (fs7.existsSync(archPath)) {
-    console.log("  \u25CB .kody/memory/architecture.md (exists, not overwriting)");
+  const conventionsPath = path6.join(memoryDir, "conventions.md");
+  if (fs7.existsSync(archPath) && !opts.force) {
+    console.log("  \u25CB .kody/memory/architecture.md (exists, use --force to regenerate)");
+  } else if (smartResult?.architecture) {
+    fs7.writeFileSync(archPath, smartResult.architecture);
+    const lineCount = smartResult.architecture.split("\n").length;
+    console.log(`  \u2713 .kody/memory/architecture.md (${lineCount} lines, LLM-generated)`);
   } else {
     const archItems = detectArchitecture(cwd);
     if (archItems.length > 0) {
-      fs7.mkdirSync(memoryDir, { recursive: true });
       const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-      const content = `# Architecture (auto-detected ${timestamp2})
+      fs7.writeFileSync(archPath, `# Architecture (auto-detected ${timestamp2})
 
 ## Overview
 ${archItems.join("\n")}
-`;
-      fs7.writeFileSync(archPath, content);
-      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items detected)`);
-      for (const item of archItems) {
-        console.log(`    ${item}`);
-      }
+`);
+      console.log(`  \u2713 .kody/memory/architecture.md (${archItems.length} items, basic detection)`);
     } else {
       console.log("  \u25CB No architecture detected");
     }
   }
-  const conventionsPath = path6.join(memoryDir, "conventions.md");
-  if (!fs7.existsSync(conventionsPath)) {
-    fs7.mkdirSync(memoryDir, { recursive: true });
+  if (fs7.existsSync(conventionsPath) && !opts.force) {
+    console.log("  \u25CB .kody/memory/conventions.md (exists, use --force to regenerate)");
+  } else if (smartResult?.conventions) {
+    fs7.writeFileSync(conventionsPath, smartResult.conventions);
+    const lineCount = smartResult.conventions.split("\n").length;
+    console.log(`  \u2713 .kody/memory/conventions.md (${lineCount} lines, LLM-generated)`);
+  } else {
     fs7.writeFileSync(conventionsPath, "# Conventions\n\n<!-- Auto-learned conventions will be appended here -->\n");
     console.log("  \u2713 .kody/memory/conventions.md (seed)");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine-lite",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Autonomous SDLC pipeline: Kody orchestration + Claude Code + LiteLLM",
   "license": "MIT",
   "type": "module",