@kody-ade/kody-engine-lite 0.1.133 → 0.1.135

package/dist/bin/cli.js

@@ -1183,8 +1183,8 @@ async function tryStartLitellm(url, projectDir, generatedConfig) {
       logger.info(`  Loaded API keys: ${Object.keys(dotenvVars).join(", ")}`);
     }
   }
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2(cmd, args2, {
+  const { spawn: spawn3 } = await import("child_process");
+  const child = spawn3(cmd, args2, {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
     env: { ...process.env, ...dotenvVars }
@@ -2610,8 +2610,8 @@ async function startProxy(config, url) {
   fs13.writeFileSync(CONFIG_PATH, config);
   const portMatch = url.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "4099";
-  const { spawn: spawn2 } = await import("child_process");
-  const child = spawn2("litellm", ["--config", CONFIG_PATH, "--port", port], {
+  const { spawn: spawn3 } = await import("child_process");
+  const child = spawn3("litellm", ["--config", CONFIG_PATH, "--port", port], {
     stdio: ["ignore", "pipe", "pipe"],
     detached: true,
     env: process.env
@@ -3741,7 +3741,15 @@ function getDevServerInfo(taskDir) {
 }
 function getBrowserToolGuidance(stageName, taskDir) {
   const devServer = getDevServerInfo(taskDir);
-  const devServerBlock = devServer ? `
+  const engineManagedServer = process.env.KODY_DEV_SERVER_READY !== void 0;
+  const serverReady = process.env.KODY_DEV_SERVER_READY === "true";
+  const serverUrl = process.env.KODY_DEV_SERVER_URL ?? devServer?.url;
+  const devServerBlock = engineManagedServer ? serverReady ? `
+### Dev Server
+The dev server is already running at ${serverUrl}. Do NOT start it yourself.
+You can use browser tools to navigate to ${serverUrl} directly.` : `
+### Dev Server
+The dev server failed to start (e.g. DB connection issues). Skip browser verification and proceed with code-only changes. Do NOT attempt to start the dev server yourself \u2014 it will hang.` : devServer ? `
 ### Dev Server Setup (REQUIRED before browsing)
 You MUST start the dev server before using any browser navigation tools:
 \`\`\`bash
@@ -3963,6 +3971,76 @@ var init_runner_selection = __esm({
   }
 });
 
+// src/dev-server.ts
+import { spawn as spawn2 } from "child_process";
+async function pollReady(url, timeoutSec) {
+  const deadline = Date.now() + timeoutSec * 1e3;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(2e3) });
+      if (res.ok || res.status >= 200 && res.status < 400) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  return false;
+}
+async function startDevServer(opts) {
+  const timeout = opts.readyTimeout ?? 30;
+  const [cmd, ...args2] = opts.command.split(/\s+/);
+  let child;
+  try {
+    child = spawn2(cmd, args2, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
+      shell: true,
+      env: { ...process.env, ...opts.envVars }
+    });
+  } catch (err) {
+    logger.warn(`  Dev server failed to spawn: ${err instanceof Error ? err.message : String(err)}`);
+    return { ready: false, url: opts.url, pid: void 0, stop: () => {
+    } };
+  }
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  let exited = false;
+  child.on("exit", () => {
+    exited = true;
+  });
+  child.unref();
+  const ready = await pollReady(opts.url, timeout);
+  if (!ready) {
+    if (exited) {
+      logger.warn(`  Dev server exited before becoming ready`);
+    } else {
+      logger.warn(`  Dev server did not respond within ${timeout}s at ${opts.url}`);
+    }
+    if (stderr) {
+      logger.warn(`  Dev server stderr (last 500 chars): ${stderr.slice(-500)}`);
+    }
+  }
+  const pid = child.pid;
+  const stop = () => {
+    try {
+      if (pid) process.kill(-pid, "SIGTERM");
+    } catch {
+    }
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+  };
+  return { ready, url: opts.url, pid, stop };
+}
+var init_dev_server = __esm({
+  "src/dev-server.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
 // src/stages/agent.ts
 import * as fs19 from "fs";
 import * as path17 from "path";
@@ -4020,6 +4098,29 @@ async function executeAgentStage(ctx, def) {
   if (mcpConfigJson) {
     logger.info(`  MCP servers enabled for ${def.name}`);
   }
+  let devServerHandle = null;
+  const ds = config.mcp?.devServer;
+  if (mcpConfigJson && ds && taskHasUI(ctx.taskDir)) {
+    logger.info(`  Starting dev server: ${ds.command}`);
+    const envVars = {};
+    for (const varName of ds.env ?? []) {
+      if (process.env[varName]) envVars[varName] = process.env[varName];
+    }
+    devServerHandle = await startDevServer({
+      command: ds.command,
+      url: ds.url,
+      readyTimeout: ds.readyTimeout ?? 30,
+      envVars
+    });
+    if (devServerHandle.ready) {
+      logger.info(`  Dev server ready at ${ds.url}`);
+      extraEnv.KODY_DEV_SERVER_URL = ds.url;
+      extraEnv.KODY_DEV_SERVER_READY = "true";
+    } else {
+      logger.warn(`  Dev server not ready \u2014 Claude will work without browser verification`);
+      extraEnv.KODY_DEV_SERVER_READY = "false";
+    }
+  }
   const runner = getRunnerForStage(ctx, def.name);
   const maxRetries = def.maxRetries ?? 0;
   let lastResult = await runner.run(def.name, prompt, model, def.timeout, ctx.taskDir, {
@@ -4047,6 +4148,10 @@ async function executeAgentStage(ctx, def) {
       mcpConfigJson
     });
   }
+  if (devServerHandle) {
+    devServerHandle.stop();
+    logger.info(`  Dev server stopped`);
+  }
   if (lastResult.outcome !== "completed") {
     return { outcome: lastResult.outcome, error: lastResult.error, retries };
   }
@@ -4137,6 +4242,7 @@ var init_agent = __esm({
     init_config();
     init_mcp_config();
     init_runner_selection();
+    init_dev_server();
     init_logger();
     SESSION_GROUP = {
       taskify: "explore",
@@ -7689,74 +7795,80 @@ function detectToolsForBootstrap(cwd) {
     (tool) => tool.detect.some((pattern) => fs8.existsSync(path7.join(cwd, pattern)))
   );
 }
-var FRAMEWORK_SKILL_RULES = [
-  {
-    detect: (deps) => "next" in deps,
-    skills: [
-      { skill: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices" },
-      { skill: "wshobson/agents@nextjs-app-router-patterns", label: "Next.js App Router patterns" }
-    ]
-  },
-  {
-    detect: (deps) => "react" in deps && !("next" in deps),
-    skills: [
-      { skill: "vercel-labs/agent-skills@vercel-react-best-practices", label: "React best practices" }
-    ]
-  },
-  {
-    detect: (deps) => "vue" in deps,
-    skills: [
-      { skill: "antfu/skills@vue", label: "Vue best practices" }
-    ]
-  },
-  {
-    detect: (deps) => "svelte" in deps || "@sveltejs/kit" in deps,
-    skills: [
-      { skill: "ejirocodes/agent-skills@svelte5-best-practices", label: "Svelte best practices" }
-    ]
-  },
-  {
-    detect: (deps) => "@angular/core" in deps,
-    skills: [
-      { skill: "analogjs/angular-skills@angular-component", label: "Angular component patterns" }
-    ]
-  },
-  {
-    detect: (deps) => "payload" in deps,
-    skills: [
-      { skill: "payloadcms/skills@payload", label: "Payload CMS patterns" }
-    ]
-  },
-  {
-    detect: (deps) => "tailwindcss" in deps,
-    skills: [
-      { skill: "wshobson/agents@tailwind-design-system", label: "Tailwind design system" }
-    ]
-  }
-];
-function detectFrameworkSkills(cwd) {
+var FRAMEWORK_KEYWORDS = {
+  next: "nextjs",
+  react: "react",
+  vue: "vue",
+  svelte: "svelte",
+  "@angular/core": "angular",
+  payload: "payload cms",
+  tailwindcss: "tailwind",
+  nuxt: "nuxt",
+  astro: "astro",
+  "solid-js": "solidjs",
+  express: "express",
+  fastify: "fastify",
+  prisma: "prisma"
+};
+function parseSkillsSearchOutput(output) {
+  const stripped = output.replace(/\x1b\[[0-9;]*m/g, "");
+  const results = [];
+  for (const line of stripped.split("\n")) {
+    const match = line.match(/^([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+)\s+([\d.]+)([KM]?)\s+installs/);
+    if (!match) continue;
+    const ref = match[1];
+    const name = ref.split("@").pop() ?? "";
+    let installs = parseFloat(match[2]);
+    if (match[3] === "K") installs *= 1e3;
+    if (match[3] === "M") installs *= 1e6;
+    results.push({ ref, name, installs });
+  }
+  return results;
+}
+function detectProjectKeywords(cwd) {
   const pkgPath = path7.join(cwd, "package.json");
   if (!fs8.existsSync(pkgPath)) return [];
   try {
     const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    const seen = /* @__PURE__ */ new Set();
-    const skills = [];
-    for (const rule of FRAMEWORK_SKILL_RULES) {
-      if (rule.detect(allDeps)) {
-        for (const skill of rule.skills) {
-          if (!seen.has(skill.skill)) {
-            seen.add(skill.skill);
-            skills.push(skill);
-          }
-        }
-      }
+    const keywords = [];
+    for (const [dep, keyword] of Object.entries(FRAMEWORK_KEYWORDS)) {
+      if (dep in allDeps) keywords.push(keyword);
     }
-    return skills;
+    return keywords;
   } catch {
     return [];
   }
 }
+function searchSkills(keywords, exclude, limit) {
+  const allResults = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const keyword of keywords) {
+    try {
+      const output = execFileSync4("npx", ["skills", "find", keyword], {
+        encoding: "utf-8",
+        timeout: 15e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      for (const skill of parseSkillsSearchOutput(output)) {
+        if (!seen.has(skill.ref) && !exclude.has(skill.name)) {
+          seen.add(skill.ref);
+          allResults.push(skill);
+        }
+      }
+    } catch {
+    }
+  }
+  return allResults.sort((a, b) => b.installs - a.installs).slice(0, limit);
+}
+function collectSkillPaths(cwd, skillName, paths) {
+  for (const dir of [".claude/skills", ".agents/skills"]) {
+    const skillPath = path7.join(dir, skillName);
+    if (fs8.existsSync(path7.join(cwd, skillPath))) {
+      paths.push(skillPath);
+    }
+  }
+}
 function bootstrapCommand(opts, pkgRoot) {
   const cwd = process.cwd();
   setConfigDir(cwd);
@@ -8213,44 +8325,66 @@ ${entries}
   }
   console.log("\n\u2500\u2500 Skills \u2500\u2500");
   const installedSkillPaths = [];
-  const allSkills = [];
-  const seen = /* @__PURE__ */ new Set();
+  const excludeSkills = /* @__PURE__ */ new Set();
+  const claudeSkillsDir = path7.join(cwd, ".claude", "skills");
+  if (fs8.existsSync(claudeSkillsDir)) {
+    try {
+      for (const entry of fs8.readdirSync(claudeSkillsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() || entry.isSymbolicLink()) excludeSkills.add(entry.name);
+      }
+    } catch {
+    }
+  }
   for (const tool of detectToolsForBootstrap(cwd)) {
-    if (tool.skill && !seen.has(tool.skill)) {
-      seen.add(tool.skill);
-      allSkills.push({ skill: tool.skill, label: `${tool.name} CLI` });
+    if (tool.skill) {
+      const toolSkillName = tool.skill.split("@").pop() ?? "";
+      excludeSkills.add(toolSkillName);
     }
   }
-  for (const mapping of detectFrameworkSkills(cwd)) {
-    if (!seen.has(mapping.skill)) {
-      seen.add(mapping.skill);
-      allSkills.push(mapping);
+  for (const tool of detectToolsForBootstrap(cwd)) {
+    if (!tool.skill) continue;
+    const skillName = tool.skill.split("@").pop() ?? "";
+    if (excludeSkills.has(skillName) && fs8.existsSync(path7.join(claudeSkillsDir, skillName))) continue;
+    try {
+      console.log(`  Installing: ${tool.name} CLI (${tool.skill})`);
+      execFileSync4("npx", ["skills", "add", tool.skill, "--yes"], {
+        cwd,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      collectSkillPaths(cwd, skillName, installedSkillPaths);
+      excludeSkills.add(skillName);
+      console.log(`  \u2713 ${tool.name} CLI`);
+    } catch {
+      console.log(`  \u2717 ${tool.name} CLI \u2014 failed to install`);
     }
   }
-  if (allSkills.length > 0) {
-    for (const { skill, label } of allSkills) {
-      try {
-        console.log(`  Installing: ${label} (${skill})`);
-        execFileSync4("npx", ["skills", "add", skill, "--yes"], {
-          cwd,
-          encoding: "utf-8",
-          timeout: 6e4,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        const skillName = skill.split("@").pop() ?? "";
-        for (const dir of [".claude/skills", ".agents/skills"]) {
-          const skillPath = path7.join(dir, skillName);
-          if (fs8.existsSync(path7.join(cwd, skillPath))) {
-            installedSkillPaths.push(skillPath);
-          }
+  const keywords = detectProjectKeywords(cwd);
+  if (keywords.length > 0) {
+    console.log(`  Searching skills.sh for: ${keywords.join(", ")}`);
+    const found = searchSkills(keywords, excludeSkills, 5);
+    if (found.length > 0) {
+      for (const skill of found) {
+        try {
+          console.log(`  Installing: ${skill.name} (${skill.ref})`);
+          execFileSync4("npx", ["skills", "add", skill.ref, "--yes"], {
+            cwd,
+            encoding: "utf-8",
+            timeout: 6e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          collectSkillPaths(cwd, skill.name, installedSkillPaths);
+          console.log(`  \u2713 ${skill.name}`);
+        } catch {
+          console.log(`  \u2717 ${skill.name} \u2014 failed to install`);
         }
-        console.log(`  \u2713 ${label}`);
-      } catch {
-        console.log(`  \u2717 ${label} \u2014 failed to install`);
       }
+    } else {
+      console.log("  \u25CB No matching skills found on skills.sh");
     }
   } else {
-    console.log("  \u25CB No skills to install (no frameworks detected)");
+    console.log("  \u25CB No frameworks detected \u2014 skipping skill search");
   }
   if (fs8.existsSync(path7.join(cwd, "skills-lock.json"))) {
     installedSkillPaths.push("skills-lock.json");

package/package.json

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