jinzd-ai-cli 0.1.66 → 0.1.68

package/dist/chunk-K4Q235ZG.js

@@ -0,0 +1,473 @@
+#!/usr/bin/env node
+
+// src/tools/builtin/run-tests.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { platform } from "os";
+import chalk from "chalk";
+
+// src/core/constants.ts
+var VERSION = "0.1.68";
+var APP_NAME = "ai-cli";
+var CONFIG_DIR_NAME = ".aicli";
+var CONFIG_FILE_NAME = "config.json";
+var HISTORY_DIR_NAME = "history";
+var PLUGINS_DIR_NAME = "plugins";
+var SKILLS_DIR_NAME = "skills";
+var CUSTOM_COMMANDS_DIR_NAME = "commands";
+var CONTEXT_FILE_CANDIDATES = ["AICLI.md", "CLAUDE.md"];
+var MEMORY_FILE_NAME = "memory.md";
+var MEMORY_MAX_CHARS = 1e4;
+var DEV_STATE_FILE_NAME = "dev-state.md";
+var DEFAULT_MAX_TOKENS = 8192;
+var MCP_TOOL_PREFIX = "mcp__";
+var MCP_PROJECT_CONFIG_NAME = ".mcp.json";
+var MCP_CONNECT_TIMEOUT = 3e4;
+var MCP_CALL_TIMEOUT = 6e4;
+var MCP_PROTOCOL_VERSION = "2024-11-05";
+var PLAN_MODE_READONLY_TOOLS = /* @__PURE__ */ new Set([
+  "read_file",
+  "list_dir",
+  "grep_files",
+  "glob_files",
+  "web_fetch",
+  "google_search",
+  "ask_user",
+  // 允许：可向用户澄清需求
+  "write_todos"
+  // 允许：可输出任务列表作为实施计划
+]);
+var PLAN_MODE_SYSTEM_ADDON = `# \u{1F50D} Plan Mode \u2014 Read-Only Planning Mode
+
+You are currently in read-only planning (Plan) mode.
+
+**Allowed tools**: read_file \xB7 list_dir \xB7 grep_files \xB7 glob_files \xB7 web_fetch \xB7 google_search \xB7 ask_user \xB7 write_todos
+**Disabled tools**: bash \xB7 write_file \xB7 edit_file \xB7 run_interactive \xB7 save_last_response \xB7 save_memory and all MCP tools
+
+**Your task**:
+1. Use read-only tools to thoroughly analyze the codebase, file structure, and existing implementation
+2. Use ask_user to clarify any ambiguous requirements with the user
+3. Develop a detailed implementation plan (you may use write_todos to present the task list), including:
+   - List of files to be modified or created
+   - Specific changes for each file
+   - Execution order and dependencies
+   - Potential risks and considerations
+
+Once planning is complete, clearly inform the user: type \`/plan execute\` to begin executing the plan, or \`/plan exit\` to discard it.`;
+var SUBAGENT_DEFAULT_MAX_ROUNDS = 10;
+var SUBAGENT_MAX_ROUNDS_LIMIT = 15;
+var SUBAGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "read_file",
+  "write_file",
+  "edit_file",
+  "list_dir",
+  "grep_files",
+  "glob_files",
+  "run_interactive",
+  "web_fetch",
+  "google_search",
+  "write_todos",
+  "run_tests"
+]);
+var CONTEXT_PRESSURE_THRESHOLD = 0.8;
+var TEST_TIMEOUT = 3e5;
+var AGENTIC_BEHAVIOR_GUIDELINE = `# Important Behavioral Guidelines
+
+**Distinguish between "understanding" and "executing"**:
+- When the user asks you to "read", "understand", "review", "analyze", "examine", or "look at" files or a project, your task is only to **read and summarize**, then wait for the user's next instruction. Do not automatically start executing tasks described in the project.
+- Only begin using write/execute tools when the user **explicitly requests** an action (e.g., "generate", "create", "modify", "run", "start", etc.).
+- If you are unsure about the user's intent, use the ask_user tool to confirm with the user, rather than assuming and executing on your own.`;
+var AUTHOR = "Jin Zhengdong";
+var AUTHOR_EMAIL = "zhengdong.jin@gmail.com";
+var DESCRIPTION = "Cross-platform REPL-style AI conversation tool with multi-provider and agentic tool calling support";
+var REPO_URL = "https://github.com/jinzhengdong/ai-cli";
+
+// src/tools/builtin/run-tests.ts
+var IS_WINDOWS = platform() === "win32";
+function detectNodeTestFramework(cwd, pkg) {
+  const devDeps = pkg.devDependencies ?? {};
+  const deps = pkg.dependencies ?? {};
+  const allDeps = { ...deps, ...devDeps };
+  if ("vitest" in allDeps || existsSync(join(cwd, "vitest.config.ts")) || existsSync(join(cwd, "vitest.config.js")) || existsSync(join(cwd, "vitest.config.mts"))) {
+    return { type: "node", framework: "vitest", command: "npx vitest run" };
+  }
+  if ("jest" in allDeps || existsSync(join(cwd, "jest.config.js")) || existsSync(join(cwd, "jest.config.ts")) || existsSync(join(cwd, "jest.config.mjs"))) {
+    return { type: "node", framework: "jest", command: "npx jest" };
+  }
+  if ("mocha" in allDeps || existsSync(join(cwd, ".mocharc.yml")) || existsSync(join(cwd, ".mocharc.yaml")) || existsSync(join(cwd, ".mocharc.json")) || existsSync(join(cwd, ".mocharc.js"))) {
+    return { type: "node", framework: "mocha", command: "npx mocha" };
+  }
+  if ("ava" in allDeps) {
+    return { type: "node", framework: "ava", command: "npx ava" };
+  }
+  if ("@playwright/test" in allDeps) {
+    return { type: "node", framework: "playwright", command: "npx playwright test" };
+  }
+  return null;
+}
+function safeReadPackageJson(cwd) {
+  const filePath = join(cwd, "package.json");
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "EACCES" || code === "EPERM") {
+      process.stderr.write(`[Warning] Permission denied reading package.json (${code})
+`);
+    } else {
+      process.stderr.write(
+        `[Warning] Cannot read package.json: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+    return null;
+  }
+  if (raw.charCodeAt(0) === 65279) {
+    raw = raw.slice(1);
+  }
+  if (!raw.trim()) {
+    process.stderr.write("[Warning] package.json is empty\n");
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      process.stderr.write("[Warning] package.json root is not a JSON object\n");
+      return null;
+    }
+    return parsed;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Unexpected token")) {
+      process.stderr.write(`[Warning] package.json has syntax error: ${msg}
+`);
+    } else if (msg.includes("Unexpected end")) {
+      process.stderr.write("[Warning] package.json is truncated or incomplete\n");
+    } else {
+      process.stderr.write(`[Warning] package.json parse failed: ${msg}
+`);
+    }
+    return null;
+  }
+}
+function detectProject(cwd) {
+  if (existsSync(join(cwd, "pom.xml"))) {
+    return { type: "java", framework: "Maven (JUnit)", command: IS_WINDOWS ? "mvn.cmd test" : "mvn test" };
+  }
+  if (existsSync(join(cwd, "build.gradle")) || existsSync(join(cwd, "build.gradle.kts"))) {
+    const wrapper = IS_WINDOWS ? "gradlew.bat" : "./gradlew";
+    const cmd = existsSync(join(cwd, IS_WINDOWS ? "gradlew.bat" : "gradlew")) ? `${wrapper} test` : "gradle test";
+    return { type: "java", framework: "Gradle (JUnit)", command: cmd };
+  }
+  if (existsSync(join(cwd, "package.json"))) {
+    const pkg = safeReadPackageJson(cwd);
+    if (pkg) {
+      const testScript = pkg.scripts?.test;
+      if (testScript && testScript !== 'echo "Error: no test specified" && exit 1') {
+        return { type: "node", framework: "npm", command: "npm test" };
+      }
+      const frameworkDetected = detectNodeTestFramework(cwd, pkg);
+      if (frameworkDetected) return frameworkDetected;
+    } else {
+      return { type: "node", framework: "npm (package.json error)", command: "npm test" };
+    }
+  }
+  if (existsSync(join(cwd, "pyproject.toml")) || existsSync(join(cwd, "setup.py")) || existsSync(join(cwd, "pytest.ini"))) {
+    return { type: "python", framework: "pytest", command: "pytest -v" };
+  }
+  if (existsSync(join(cwd, "Cargo.toml"))) {
+    return { type: "rust", framework: "cargo", command: "cargo test" };
+  }
+  if (existsSync(join(cwd, "go.mod"))) {
+    return { type: "go", framework: "go test", command: "go test ./..." };
+  }
+  return null;
+}
+function parseJUnitXml(xmlContent) {
+  const summary = { tests: 0, passed: 0, failures: 0, errors: 0, skipped: 0, duration: 0, failedTests: [] };
+  const suiteMatch = xmlContent.match(/<testsuite[^>]*\btests="(\d+)"[^>]*/);
+  if (suiteMatch) {
+    summary.tests = parseInt(suiteMatch[1], 10);
+    const failMatch = xmlContent.match(/<testsuite[^>]*\bfailures="(\d+)"/);
+    const errMatch = xmlContent.match(/<testsuite[^>]*\berrors="(\d+)"/);
+    const skipMatch = xmlContent.match(/<testsuite[^>]*\bskipped="(\d+)"/);
+    const timeMatch = xmlContent.match(/<testsuite[^>]*\btime="([^"]*)"/);
+    summary.failures = failMatch ? parseInt(failMatch[1], 10) : 0;
+    summary.errors = errMatch ? parseInt(errMatch[1], 10) : 0;
+    summary.skipped = skipMatch ? parseInt(skipMatch[1], 10) : 0;
+    summary.duration = timeMatch ? parseFloat(timeMatch[1]) : 0;
+    summary.passed = summary.tests - summary.failures - summary.errors - summary.skipped;
+  }
+  const tcPattern = /<testcase[^>]*\bname="([^"]*)"[^>]*classname="([^"]*)"[^>]*>[\s\S]*?<(failure|error)[^>]*>([^<]*)/g;
+  let m;
+  while ((m = tcPattern.exec(xmlContent)) !== null) {
+    summary.failedTests.push({
+      name: `${m[2]}#${m[1]}`,
+      message: m[4].trim().slice(0, 200)
+    });
+  }
+  return summary;
+}
+function findJUnitReports(cwd) {
+  const dirs = [
+    join(cwd, "target", "surefire-reports"),
+    // Maven
+    join(cwd, "build", "test-results", "test"),
+    // Gradle
+    join(cwd, "build", "test-results")
+    // Gradle (older)
+  ];
+  const xmlFiles = [];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    try {
+      const files = readdirSync(dir);
+      for (const f of files) {
+        if (f.endsWith(".xml")) xmlFiles.push(join(dir, f));
+      }
+    } catch {
+    }
+  }
+  return xmlFiles;
+}
+function parseGenericOutput(output) {
+  const mvn = output.match(/Tests run:\s*(\d+),\s*Failures:\s*(\d+),\s*Errors:\s*(\d+),\s*Skipped:\s*(\d+)/);
+  if (mvn) {
+    const [, tests, failures, errors, skipped] = mvn.map(Number);
+    return { tests, failures, errors, skipped, passed: tests - failures - errors - skipped };
+  }
+  const jest = output.match(/Tests:\s+(?:(\d+)\s+passed,?\s*)?(?:(\d+)\s+failed,?\s*)?(?:(\d+)\s+skipped,?\s*)?(\d+)\s+total/);
+  if (jest) {
+    const passed = parseInt(jest[1] ?? "0", 10);
+    const failures = parseInt(jest[2] ?? "0", 10);
+    const skipped = parseInt(jest[3] ?? "0", 10);
+    const tests = parseInt(jest[4], 10);
+    return { tests, passed, failures, skipped, errors: 0 };
+  }
+  const pytest = output.match(/(\d+)\s+passed(?:.*?(\d+)\s+failed)?(?:.*?(\d+)\s+error)?/);
+  if (pytest) {
+    const passed = parseInt(pytest[1], 10);
+    const failures = parseInt(pytest[2] ?? "0", 10);
+    const errors = parseInt(pytest[3] ?? "0", 10);
+    return { tests: passed + failures + errors, passed, failures, errors, skipped: 0 };
+  }
+  const cargo = output.match(/test result:.*?(\d+)\s+passed;\s*(\d+)\s+failed;\s*(\d+)\s+ignored/);
+  if (cargo) {
+    const passed = parseInt(cargo[1], 10);
+    const failures = parseInt(cargo[2], 10);
+    const skipped = parseInt(cargo[3], 10);
+    return { tests: passed + failures + skipped, passed, failures, skipped, errors: 0 };
+  }
+  const goPass = (output.match(/^ok\s/gm) ?? []).length;
+  const goFail = (output.match(/^FAIL\s/gm) ?? []).length;
+  if (goPass + goFail > 0) {
+    return { tests: goPass + goFail, passed: goPass, failures: goFail, errors: 0, skipped: 0 };
+  }
+  return null;
+}
+function formatReport(summary, framework, output, exitCode) {
+  const status = summary.failures + summary.errors > 0 ? "FAILED \u2717" : "PASSED \u2713";
+  const lines = [];
+  lines.push(`## Test Results \u2014 ${status}`);
+  lines.push(`**Total: ${summary.tests} | Passed: ${summary.passed} | Failed: ${summary.failures}${summary.errors > 0 ? ` | Errors: ${summary.errors}` : ""} | Skipped: ${summary.skipped}**`);
+  if (summary.duration > 0) {
+    lines.push(`Duration: ${summary.duration.toFixed(1)}s | Framework: ${framework}`);
+  } else {
+    lines.push(`Framework: ${framework}`);
+  }
+  if (summary.failedTests.length > 0) {
+    lines.push("");
+    lines.push("### Failed Tests");
+    for (const ft of summary.failedTests) {
+      lines.push(`- ${ft.name} \u2014 ${ft.message}`);
+    }
+  }
+  const outputLines = output.split("\n");
+  const tail = outputLines.length > 150 ? outputLines.slice(-150) : outputLines;
+  lines.push("");
+  lines.push(`### Output (last ${tail.length} lines)`);
+  lines.push("```");
+  lines.push(tail.join("\n"));
+  lines.push("```");
+  return lines.join("\n");
+}
+function renderColorReport(summary, framework) {
+  const isPass = summary.failures + summary.errors === 0;
+  const status = isPass ? chalk.green.bold("PASSED \u2713") : chalk.red.bold("FAILED \u2717");
+  console.log();
+  console.log(`  ${chalk.bold("Test Results")} \u2014 ${status}`);
+  console.log(
+    `  Total: ${chalk.bold(String(summary.tests))} | ${chalk.green(`Passed: ${summary.passed}`)} | ${chalk.red(`Failed: ${summary.failures}`)}` + (summary.errors > 0 ? ` | ${chalk.red(`Errors: ${summary.errors}`)}` : "") + ` | ${chalk.yellow(`Skipped: ${summary.skipped}`)}`
+  );
+  if (summary.duration > 0) {
+    console.log(`  Duration: ${summary.duration.toFixed(1)}s | Framework: ${framework}`);
+  }
+  if (summary.failedTests.length > 0) {
+    console.log(chalk.red("\n  Failed Tests:"));
+    for (const ft of summary.failedTests) {
+      console.log(chalk.red(`    - ${ft.name}`));
+      if (ft.message) console.log(chalk.dim(`      ${ft.message}`));
+    }
+  }
+  console.log();
+}
+async function executeTests(args) {
+  const cwd = process.cwd();
+  const customCmd = args["command"] ? String(args["command"]).trim() : "";
+  const filter = args["filter"] ? String(args["filter"]).trim() : "";
+  let command;
+  let framework;
+  if (customCmd) {
+    command = customCmd;
+    framework = "custom";
+  } else {
+    const detected = detectProject(cwd);
+    if (!detected) {
+      return "Error: Could not detect project type. No pom.xml, build.gradle, package.json, pyproject.toml, Cargo.toml, or go.mod found.\nPlease specify a test command using the `command` parameter.";
+    }
+    command = detected.command;
+    framework = detected.framework;
+    if (filter) {
+      if (detected.type === "java" && command.includes("mvn")) {
+        command += ` -Dtest="${filter}"`;
+      } else if (detected.type === "python") {
+        command += ` -k "${filter}"`;
+      } else if (detected.type === "rust") {
+        command += ` ${filter}`;
+      } else if (detected.type === "go") {
+        command = `go test ./... -run "${filter}"`;
+      } else if (detected.type === "node") {
+        if (detected.framework === "vitest") {
+          command += ` -t "${filter}"`;
+        } else if (detected.framework === "jest") {
+          command += ` -t "${filter}"`;
+        } else if (detected.framework === "mocha") {
+          command += ` --grep "${filter}"`;
+        } else if (detected.framework === "playwright") {
+          command += ` --grep "${filter}"`;
+        } else {
+          command += ` -- --grep "${filter}"`;
+        }
+      }
+    }
+  }
+  let output;
+  let exitCode = 0;
+  try {
+    const buf = execSync(command, {
+      cwd,
+      timeout: TEST_TIMEOUT,
+      encoding: "buffer",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        ...IS_WINDOWS ? {} : { FORCE_COLOR: "0" }
+      }
+    });
+    output = buf.toString("utf-8");
+  } catch (err) {
+    const e = err;
+    exitCode = e.status ?? 1;
+    const stdout = e.stdout?.toString("utf-8") ?? "";
+    const stderr = e.stderr?.toString("utf-8") ?? "";
+    output = stdout + (stderr ? "\n" + stderr : "");
+  }
+  let summary = {
+    tests: 0,
+    passed: 0,
+    failures: 0,
+    errors: 0,
+    skipped: 0,
+    duration: 0,
+    failedTests: []
+  };
+  const xmlFiles = findJUnitReports(cwd);
+  if (xmlFiles.length > 0) {
+    for (const xmlFile of xmlFiles) {
+      try {
+        const xml = readFileSync(xmlFile, "utf-8");
+        const parsed = parseJUnitXml(xml);
+        summary.tests += parsed.tests;
+        summary.passed += parsed.passed;
+        summary.failures += parsed.failures;
+        summary.errors += parsed.errors;
+        summary.skipped += parsed.skipped;
+        summary.duration += parsed.duration;
+        summary.failedTests.push(...parsed.failedTests);
+      } catch {
+      }
+    }
+  } else {
+    const parsed = parseGenericOutput(output);
+    if (parsed) {
+      summary = { ...summary, ...parsed };
+    } else {
+      summary.tests = 1;
+      if (exitCode === 0) {
+        summary.passed = 1;
+      } else {
+        summary.failures = 1;
+      }
+    }
+  }
+  renderColorReport(summary, framework);
+  return formatReport(summary, framework, output, exitCode);
+}
+var runTestsTool = {
+  definition: {
+    name: "run_tests",
+    description: "Run project tests and return a structured report. Auto-detects project type (Maven/Gradle/npm/pytest/cargo/go). Returns test counts (passed/failed/skipped) and failed test details.",
+    parameters: {
+      command: {
+        type: "string",
+        description: "Optional: custom test command to run (overrides auto-detection)",
+        required: false
+      },
+      filter: {
+        type: "string",
+        description: 'Optional: test name filter/pattern (e.g., "ExamService" to run only matching tests)',
+        required: false
+      }
+    }
+  },
+  async execute(args) {
+    return executeTests(args);
+  }
+};
+
+export {
+  VERSION,
+  APP_NAME,
+  CONFIG_DIR_NAME,
+  CONFIG_FILE_NAME,
+  HISTORY_DIR_NAME,
+  PLUGINS_DIR_NAME,
+  SKILLS_DIR_NAME,
+  CUSTOM_COMMANDS_DIR_NAME,
+  CONTEXT_FILE_CANDIDATES,
+  MEMORY_FILE_NAME,
+  MEMORY_MAX_CHARS,
+  DEV_STATE_FILE_NAME,
+  DEFAULT_MAX_TOKENS,
+  MCP_TOOL_PREFIX,
+  MCP_PROJECT_CONFIG_NAME,
+  MCP_CONNECT_TIMEOUT,
+  MCP_CALL_TIMEOUT,
+  MCP_PROTOCOL_VERSION,
+  PLAN_MODE_READONLY_TOOLS,
+  PLAN_MODE_SYSTEM_ADDON,
+  SUBAGENT_DEFAULT_MAX_ROUNDS,
+  SUBAGENT_MAX_ROUNDS_LIMIT,
+  SUBAGENT_ALLOWED_TOOLS,
+  CONTEXT_PRESSURE_THRESHOLD,
+  AGENTIC_BEHAVIOR_GUIDELINE,
+  AUTHOR,
+  AUTHOR_EMAIL,
+  DESCRIPTION,
+  REPO_URL,
+  executeTests,
+  runTestsTool
+};