claude-kanban 0.2.0 → 0.3.0

package/dist/bin/cli.js

@@ -16,7 +16,7 @@ import { existsSync as existsSync3 } from "fs";
 // src/server/services/executor.ts
 import { spawn, execSync } from "child_process";
 import { join as join4 } from "path";
-import { writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync2, existsSync as existsSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync4, rmSync } from "fs";
+import { writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync2, existsSync as existsSync2, appendFileSync as appendFileSync2, readFileSync as readFileSync4, rmSync, symlinkSync } from "fs";
 import { EventEmitter } from "events";
 
 // src/server/services/project.ts
@@ -36,7 +36,39 @@ function detectPackageManager(projectPath) {
   if (existsSync(join(projectPath, "bun.lockb"))) return "bun";
   return "npm";
 }
+function detectProjectType(projectPath) {
+  if (existsSync(join(projectPath, "package.json"))) return "node";
+  if (existsSync(join(projectPath, "pyproject.toml")) || existsSync(join(projectPath, "requirements.txt")) || existsSync(join(projectPath, "setup.py"))) return "python";
+  if (existsSync(join(projectPath, "composer.json"))) return "php";
+  if (existsSync(join(projectPath, "Gemfile"))) return "ruby";
+  if (existsSync(join(projectPath, "go.mod"))) return "go";
+  if (existsSync(join(projectPath, "Cargo.toml"))) return "rust";
+  return "unknown";
+}
 function detectProjectCommands(projectPath) {
+  const projectType = detectProjectType(projectPath);
+  switch (projectType) {
+    case "node":
+      return detectNodeCommands(projectPath);
+    case "python":
+      return detectPythonCommands(projectPath);
+    case "php":
+      return detectPHPCommands(projectPath);
+    case "ruby":
+      return detectRubyCommands(projectPath);
+    case "go":
+      return detectGoCommands(projectPath);
+    case "rust":
+      return detectRustCommands(projectPath);
+    default:
+      return {
+        testCommand: "",
+        typecheckCommand: "",
+        buildCommand: ""
+      };
+  }
+}
+function detectNodeCommands(projectPath) {
   const pm = detectPackageManager(projectPath);
   const run = pm === "npm" ? "npm run" : pm;
   const packageJsonPath = join(projectPath, "package.json");
@@ -48,11 +80,61 @@ function detectProjectCommands(projectPath) {
     } catch {
     }
   }
-  const testCommand = scripts.test ? `${run} test` : 'echo "No test command configured"';
-  const typecheckCommand = scripts.typecheck ? `${run} typecheck` : scripts["type-check"] ? `${run} type-check` : existsSync(join(projectPath, "tsconfig.json")) ? `${run === "npm run" ? "npx" : pm} tsc --noEmit` : 'echo "No typecheck command configured"';
-  const buildCommand = scripts.build ? `${run} build` : 'echo "No build command configured"';
+  const testCommand = scripts.test ? `${run} test` : "";
+  const typecheckCommand = scripts.typecheck ? `${run} typecheck` : scripts["type-check"] ? `${run} type-check` : existsSync(join(projectPath, "tsconfig.json")) ? `${run === "npm run" ? "npx" : pm} tsc --noEmit` : "";
+  const buildCommand = scripts.build ? `${run} build` : "";
   return { testCommand, typecheckCommand, buildCommand };
 }
+function detectPythonCommands(projectPath) {
+  const hasPytest = existsSync(join(projectPath, "pytest.ini")) || existsSync(join(projectPath, "pyproject.toml")) || existsSync(join(projectPath, "tests"));
+  const hasMypy = existsSync(join(projectPath, "mypy.ini")) || existsSync(join(projectPath, ".mypy.ini"));
+  return {
+    testCommand: hasPytest ? "pytest" : "",
+    typecheckCommand: hasMypy ? "mypy ." : "",
+    buildCommand: ""
+  };
+}
+function detectPHPCommands(projectPath) {
+  const hasPhpunit = existsSync(join(projectPath, "phpunit.xml")) || existsSync(join(projectPath, "phpunit.xml.dist"));
+  const hasPest = existsSync(join(projectPath, "tests", "Pest.php"));
+  const hasPhpstan = existsSync(join(projectPath, "phpstan.neon")) || existsSync(join(projectPath, "phpstan.neon.dist"));
+  let testCommand = "";
+  if (hasPest) {
+    testCommand = "./vendor/bin/pest";
+  } else if (hasPhpunit) {
+    testCommand = "./vendor/bin/phpunit";
+  }
+  return {
+    testCommand,
+    typecheckCommand: hasPhpstan ? "./vendor/bin/phpstan analyse" : "",
+    buildCommand: ""
+  };
+}
+function detectRubyCommands(projectPath) {
+  const hasRspec = existsSync(join(projectPath, "spec")) || existsSync(join(projectPath, ".rspec"));
+  const hasMinitest = existsSync(join(projectPath, "test"));
+  return {
+    testCommand: hasRspec ? "bundle exec rspec" : hasMinitest ? "bundle exec rake test" : "",
+    typecheckCommand: "",
+    // Ruby doesn't have built-in typechecking (sorbet is optional)
+    buildCommand: ""
+  };
+}
+function detectGoCommands(_projectPath) {
+  return {
+    testCommand: "go test ./...",
+    typecheckCommand: "go build ./...",
+    // Go's compiler is the typechecker
+    buildCommand: "go build"
+  };
+}
+function detectRustCommands(_projectPath) {
+  return {
+    testCommand: "cargo test",
+    typecheckCommand: "cargo check",
+    buildCommand: "cargo build"
+  };
+}
 function createInitialPRD(projectName) {
   return {
     version: "1.0",
@@ -494,6 +576,64 @@ var TaskExecutor = class extends EventEmitter {
     if (!existsSync2(logPath)) return null;
     return readFileSync4(logPath, "utf-8");
   }
+  /**
+   * Format tool use for display in logs
+   */
+  formatToolUse(toolName, input) {
+    const truncate = (str, maxLen = 80) => {
+      if (str.length <= maxLen) return str;
+      return str.slice(0, maxLen) + "...";
+    };
+    switch (toolName) {
+      case "Bash":
+        return `[Bash] $ ${truncate(String(input.command || ""))}
+`;
+      case "Read":
+        return `[Read] ${input.file_path}
+`;
+      case "Edit":
+        return `[Edit] ${input.file_path}
+`;
+      case "Write":
+        return `[Write] ${input.file_path}
+`;
+      case "Grep":
+        return `[Grep] "${truncate(String(input.pattern || ""))}" in ${input.path || "."}
+`;
+      case "Glob":
+        return `[Glob] ${input.pattern} in ${input.path || "."}
+`;
+      case "Task":
+        return `[Task] ${input.description || truncate(String(input.prompt || ""))}
+`;
+      case "TodoWrite":
+        const todos = input.todos;
+        if (todos && Array.isArray(todos)) {
+          const summary = todos.map((t) => `  ${t.status === "completed" ? "\u2713" : t.status === "in_progress" ? "\u2192" : "\u25CB"} ${truncate(t.content, 60)}`).join("\n");
+          return `[TodoWrite]
+${summary}
+`;
+        }
+        return `[TodoWrite]
+`;
+      case "WebFetch":
+        return `[WebFetch] ${input.url}
+`;
+      case "WebSearch":
+        return `[WebSearch] "${truncate(String(input.query || ""))}"
+`;
+      default:
+        const meaningfulParams = ["file_path", "path", "command", "query", "url", "pattern", "target"];
+        for (const param of meaningfulParams) {
+          if (input[param]) {
+            return `[${toolName}] ${truncate(String(input[param]))}
+`;
+          }
+        }
+        return `[${toolName}]
+`;
+    }
+  }
   /**
    * Check if project is a git repository
    */
@@ -559,6 +699,7 @@ var TaskExecutor = class extends EventEmitter {
         cwd: this.projectPath,
         stdio: "pipe"
       });
+      this.symlinkDependencies(worktreePath);
       console.log(`[executor] Created worktree at ${worktreePath} on branch ${branchName}`);
       return { worktreePath, branchName };
     } catch (error) {
@@ -566,6 +707,38 @@ var TaskExecutor = class extends EventEmitter {
       return null;
     }
   }
+  /**
+   * Symlink dependency directories from main project to worktree
+   */
+  symlinkDependencies(worktreePath) {
+    const depDirs = [
+      "node_modules",
+      ".pnpm",
+      // pnpm store
+      ".yarn",
+      // yarn cache
+      "vendor",
+      // PHP/Ruby deps
+      "__pycache__",
+      // Python cache
+      ".venv",
+      // Python virtual env
+      "venv"
+      // Python virtual env
+    ];
+    for (const dir of depDirs) {
+      const sourcePath = join4(this.projectPath, dir);
+      const targetPath = join4(worktreePath, dir);
+      if (existsSync2(sourcePath) && !existsSync2(targetPath)) {
+        try {
+          symlinkSync(sourcePath, targetPath, "junction");
+          console.log(`[executor] Symlinked ${dir} to worktree`);
+        } catch (error) {
+          console.log(`[executor] Could not symlink ${dir}:`, error);
+        }
+      }
+    }
+  }
   /**
    * Remove a git worktree
    */
@@ -658,6 +831,17 @@ var TaskExecutor = class extends EventEmitter {
     const stepsText = task.steps.length > 0 ? `
 Verification steps:
 ${task.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}` : "";
+    const verifySteps = [];
+    if (config.project.typecheckCommand) {
+      verifySteps.push(`Run typecheck: ${config.project.typecheckCommand}`);
+    }
+    if (config.project.testCommand) {
+      verifySteps.push(`Run tests: ${config.project.testCommand}`);
+    }
+    const verifySection = verifySteps.length > 0 ? `2. Verify your work:
+${verifySteps.map((s) => `   - ${s}`).join("\n")}
+
+` : "";
     return `You are an AI coding agent. Complete the following task:
 
 ## TASK
@@ -671,23 +855,19 @@ ${stepsText}
 ## INSTRUCTIONS
 1. Implement this task as described above.
 
-2. Verify your work:
-   - Run typecheck: ${config.project.typecheckCommand}
-   - Run tests: ${config.project.testCommand}
-
-3. When complete, update the task in ${prdPath}:
+${verifySection}${verifySteps.length > 0 ? "3" : "2"}. When complete, update the task in ${prdPath}:
    - Find the task with id "${task.id}"
    - Set "passes": true
    - Set "status": "completed"
 
-4. Document your work in ${progressPath}:
+${verifySteps.length > 0 ? "4" : "3"}. Document your work in ${progressPath}:
    - What you implemented and files changed
    - Key decisions made and why
    - Gotchas, edge cases, or tricky parts discovered
    - Useful patterns or approaches that worked well
    - Anything a future agent should know about this area of the codebase
 
-5. Make a git commit with a descriptive message.
+${verifySteps.length > 0 ? "5" : "4"}. Make a git commit with a descriptive message.
 
 Focus only on this task. When successfully complete, output: <promise>COMPLETE</promise>`;
   }
@@ -788,8 +968,7 @@ Focus only on this task. When successfully complete, output: <promise>COMPLETE</
               if (block.type === "text") {
                 text += block.text;
               } else if (block.type === "tool_use") {
-                text += `[Tool: ${block.name}]
-`;
+                text += this.formatToolUse(block.name, block.input);
               }
             }
           } else if (json.type === "content_block_delta" && json.delta?.text) {