claude-crap 0.1.2

package/src/adapters/stryker.ts

@@ -0,0 +1,218 @@
+/**
+ * Stryker (JavaScript mutation testing) adapter.
+ *
+ * Stryker emits a JSON report under `reports/mutation/mutation.json`.
+ * The report shape is documented at
+ * https://stryker-mutator.io/docs/mutation-testing-elements/mutant-result-schema/ :
+ *
+ *   {
+ *     "schemaVersion": "1.0",
+ *     "thresholds": { ... },
+ *     "files": {
+ *       "src/foo.ts": {
+ *         "language": "typescript",
+ *         "source": "...",
+ *         "mutants": [
+ *           {
+ *             "id": "1",
+ *             "mutatorName": "ConditionalExpression",
+ *             "replacement": "false",
+ *             "location": {
+ *               "start": { "line": 10, "column": 5 },
+ *               "end":   { "line": 10, "column": 15 }
+ *             },
+ *             "status": "Survived",   // Killed | Survived | Timeout | NoCoverage | RuntimeError | CompileError | Ignored
+ *             "statusReason": "..."
+ *           }
+ *         ]
+ *       }
+ *     }
+ *   }
+ *
+ * This adapter treats every **surviving mutant** as a SARIF
+ * `error`-level finding — surviving mutants are exactly the ones the
+ * Golden Rule forbids, because they prove the test suite does not
+ * pin the code's behavior tightly enough to notice a change.
+ *
+ * Mutants with status `NoCoverage` become `warning`-level findings
+ * (not blocking the Stop gate by themselves, but still ingested so
+ * the dashboard can surface uncovered lines). All other statuses are
+ * ignored — they do not represent defects.
+ *
+ * @module adapters/stryker
+ */
+
+import type { SarifLevel } from "../sarif/sarif-builder.js";
+import {
+  estimateEffortMinutes,
+  wrapResultsInSarif,
+  type AdapterResult,
+  type KnownScanner,
+} from "./common.js";
+
+const STRYKER: KnownScanner = "stryker";
+
+interface StrykerReport {
+  readonly schemaVersion?: string;
+  readonly files?: Record<string, StrykerFileReport>;
+}
+
+interface StrykerFileReport {
+  readonly language?: string;
+  readonly mutants?: ReadonlyArray<StrykerMutant>;
+}
+
+interface StrykerMutant {
+  readonly id?: string;
+  readonly mutatorName?: string;
+  readonly replacement?: string;
+  readonly location?: {
+    readonly start?: { readonly line?: number; readonly column?: number };
+    readonly end?: { readonly line?: number; readonly column?: number };
+  };
+  readonly status?: string;
+  readonly statusReason?: string;
+}
+
+/**
+ * Accept a Stryker JSON mutation report and return a normalized
+ * `PersistedSarif` document with one finding per surviving mutant
+ * and per uncovered mutant.
+ *
+ * @param input Raw Stryker report (string or parsed object).
+ * @returns     Adapter result.
+ * @throws      When the input is not a Stryker mutation report.
+ */
+export function adaptStryker(input: unknown): AdapterResult {
+  const parsed = typeof input === "string" ? (JSON.parse(input) as unknown) : input;
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error(`[adapter:stryker] expected a JSON object`);
+  }
+  const report = parsed as StrykerReport;
+  if (!report.files || typeof report.files !== "object") {
+    throw new Error(`[adapter:stryker] report is missing a files{} map`);
+  }
+
+  const results: Array<ReturnType<typeof buildSarifResult>> = [];
+  let totalEffortMinutes = 0;
+
+  for (const [filename, fileReport] of Object.entries(report.files)) {
+    const mutants = Array.isArray(fileReport?.mutants) ? fileReport.mutants : [];
+    for (const mutant of mutants) {
+      const level = classifyMutant(mutant.status);
+      if (level === null) continue; // Killed / Ignored / CompileError — not a defect
+      const startLine = mutant.location?.start?.line ?? 1;
+      const startColumn = mutant.location?.start?.column ?? 1;
+      const endLine = mutant.location?.end?.line;
+      const endColumn = mutant.location?.end?.column;
+
+      // Surviving mutants cost more to fix than the default error
+      // budget because the agent has to first write a killing test,
+      // THEN possibly rewrite the code.
+      const effortOverride = level === "error" ? 45 : 15;
+      const effort = estimateEffortMinutes(level, effortOverride);
+      totalEffortMinutes += effort;
+
+      const mutator = mutant.mutatorName ?? "Unknown";
+      const ruleId = `stryker.${mutator}`;
+      const statusText = mutant.status ?? "Unknown";
+      const message =
+        `${statusText}: ${mutator} mutant on '${mutant.replacement ?? "?"}'` +
+        (mutant.statusReason ? ` — ${mutant.statusReason}` : "");
+
+      results.push(
+        buildSarifResult({
+          ruleId,
+          level,
+          message,
+          uri: filename,
+          startLine,
+          startColumn,
+          endLine: typeof endLine === "number" ? endLine : undefined,
+          endColumn: typeof endColumn === "number" ? endColumn : undefined,
+          effortMinutes: effort,
+          mutantId: mutant.id,
+          mutator,
+          mutantStatus: statusText,
+        }),
+      );
+    }
+  }
+
+  return {
+    document: wrapResultsInSarif(STRYKER, String(report.schemaVersion ?? "unknown"), results),
+    sourceTool: STRYKER,
+    findingCount: results.length,
+    totalEffortMinutes,
+  };
+}
+
+/**
+ * Classify a Stryker mutant status into a SARIF level, or `null` when
+ * the status represents a mutant that was correctly handled by the
+ * test suite and should not produce a finding.
+ */
+function classifyMutant(status: string | undefined): SarifLevel | null {
+  switch ((status ?? "").toLowerCase()) {
+    case "survived":
+      return "error";
+    case "nocoverage":
+      return "warning";
+    case "timeout":
+      // Timeout mutants are suspicious but not proof of defect —
+      // they deserve a note so the dashboard highlights them.
+      return "note";
+    case "killed":
+    case "ignored":
+    case "compileerror":
+    case "runtimeerror":
+    default:
+      return null;
+  }
+}
+
+/**
+ * Build the SARIF `result` object for a single Stryker mutant. We
+ * propagate the mutant id, mutator name, and raw status into
+ * `properties` so the dashboard can display them as tags.
+ */
+function buildSarifResult(opts: {
+  ruleId: string;
+  level: SarifLevel;
+  message: string;
+  uri: string;
+  startLine: number;
+  startColumn: number;
+  endLine?: number | undefined;
+  endColumn?: number | undefined;
+  effortMinutes: number;
+  mutantId?: string | undefined;
+  mutator?: string | undefined;
+  mutantStatus?: string | undefined;
+}) {
+  return {
+    ruleId: opts.ruleId,
+    level: opts.level,
+    message: { text: opts.message },
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: { uri: opts.uri },
+          region: {
+            startLine: opts.startLine,
+            startColumn: opts.startColumn,
+            ...(opts.endLine !== undefined ? { endLine: opts.endLine } : {}),
+            ...(opts.endColumn !== undefined ? { endColumn: opts.endColumn } : {}),
+          },
+        },
+      },
+    ],
+    properties: {
+      sourceTool: STRYKER,
+      effortMinutes: opts.effortMinutes,
+      ...(opts.mutantId ? { mutantId: opts.mutantId } : {}),
+      ...(opts.mutator ? { mutator: opts.mutator } : {}),
+      ...(opts.mutantStatus ? { mutantStatus: opts.mutantStatus } : {}),
+    },
+  };
+}

package/src/ast/cyclomatic.ts

@@ -0,0 +1,131 @@
+/**
+ * Deterministic cyclomatic complexity walker.
+ *
+ * Given a tree-sitter subtree rooted at a function node, this module walks
+ * the tree and returns the McCabe cyclomatic complexity number. The
+ * algorithm is the standard "1 + (branching nodes + short-circuit operators)"
+ * formulation:
+ *
+ *   CC = 1
+ *      + count of branching-statement nodes (if, while, for, case, catch, ...)
+ *      + count of short-circuit operators (&&, ||, ??, `and`, `or`)
+ *      + count of ternary expressions (counted as branching nodes)
+ *
+ * The baseline of 1 represents the straight-line path through the function.
+ * Every additional branching point multiplies the set of reachable paths.
+ *
+ * The walker is deliberately language-agnostic: it consults the
+ * {@link LanguageConfig} passed in to decide which node types to count.
+ * Nested functions inside the subtree are **skipped** — each function's
+ * complexity is reported independently by {@link TreeSitterEngine}.
+ *
+ * @module ast/cyclomatic
+ */
+
+import type { LanguageConfig } from "./language-config.js";
+
+/**
+ * Minimal structural contract of a tree-sitter node. We intentionally
+ * avoid importing `web-tree-sitter` types here so this module stays
+ * unit-testable with a hand-rolled mock tree.
+ */
+export interface AstNode {
+  /** Node type name from the grammar (e.g. `"if_statement"`). */
+  readonly type: string;
+  /** Raw source text for operator detection. May be large — do not log. */
+  readonly text: string;
+  /** Zero-based child count. */
+  readonly childCount: number;
+  /** Retrieve a child by index. Returns `null` if out of range. */
+  child(index: number): AstNode | null;
+}
+
+/**
+ * Compute the cyclomatic complexity of a function subtree.
+ *
+ * @param root           Node rooted at the function (method, arrow, lambda, ...).
+ * @param languageConfig Language classification tables for node types.
+ * @returns              The McCabe cyclomatic complexity (always ≥ 1).
+ */
+export function computeCyclomaticComplexity(root: AstNode, languageConfig: LanguageConfig): number {
+  let complexity = 1;
+  walk(root, languageConfig, true, (node) => {
+    if (languageConfig.branchingNodeTypes.has(node.type)) {
+      complexity += 1;
+      return;
+    }
+    // Boolean / short-circuit operators are usually represented as
+    // "binary_expression" nodes with an operator token child. To avoid
+    // coupling to a specific grammar's node shape, we inspect the raw
+    // text of the node's direct operator child.
+    if (isBooleanExpression(node, languageConfig)) {
+      complexity += 1;
+      return;
+    }
+  });
+  return complexity;
+}
+
+/**
+ * Depth-first walk that skips any nested function subtree so that its
+ * complexity is not attributed to the enclosing function.
+ *
+ * @param node           Current node being visited.
+ * @param languageConfig Language tables used to detect nested functions.
+ * @param isRoot         `true` for the starting node (we do not skip it).
+ * @param visit          Callback invoked for every non-function descendant.
+ */
+function walk(
+  node: AstNode,
+  languageConfig: LanguageConfig,
+  isRoot: boolean,
+  visit: (n: AstNode) => void,
+): void {
+  if (!isRoot && languageConfig.functionNodeTypes.has(node.type)) {
+    // Nested function — stop the walk here. Its complexity is reported
+    // separately when the engine iterates the top-level function list.
+    return;
+  }
+  visit(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walk(child, languageConfig, false, visit);
+  }
+}
+
+/**
+ * Return `true` when `node` is a boolean / short-circuit expression that
+ * should add one to the cyclomatic complexity. We inspect the node's
+ * immediate children for an operator token whose text matches one of the
+ * language's short-circuit operators.
+ *
+ * This is a heuristic — grammars differ in how they represent operators
+ * — but it is stable enough for the five supported languages because:
+ *
+ *   - JavaScript / TypeScript / Java: binary expression with `"&&"` or `"||"` token child.
+ *   - Python: `boolean_operator` node with `"and"` / `"or"` token child.
+ *   - C#: binary expression with `"&&"`, `"||"`, or `"??"` token child.
+ *
+ * @param node           Candidate node.
+ * @param languageConfig Tables with the language's boolean operator set.
+ * @returns              `true` when the node is a counted boolean expression.
+ */
+function isBooleanExpression(node: AstNode, languageConfig: LanguageConfig): boolean {
+  // Common type names across supported grammars. We check the type first
+  // to avoid scanning text for every node in the tree.
+  if (
+    node.type !== "binary_expression" &&
+    node.type !== "boolean_operator" &&
+    node.type !== "logical_expression"
+  ) {
+    return false;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (languageConfig.booleanOperators.includes(child.text)) {
+      return true;
+    }
+  }
+  return false;
+}

package/src/ast/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Public SDK entry point for the tree-sitter based AST engine and the
+ * cyclomatic complexity walker.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import {
+ *   TreeSitterEngine,
+ *   computeCyclomaticComplexity,
+ *   detectLanguageFromPath,
+ *   type FileMetrics,
+ *   type FunctionMetrics,
+ *   type SupportedLanguage,
+ * } from "claude-crap/ast";
+ * ```
+ *
+ * @module ast
+ */
+
+export { TreeSitterEngine } from "./tree-sitter-engine.js";
+export type {
+  AnalyzeFileRequest,
+  FileMetrics,
+  FunctionMetrics,
+  TreeSitterEngineOptions,
+} from "./tree-sitter-engine.js";
+
+export { computeCyclomaticComplexity } from "./cyclomatic.js";
+export type { AstNode } from "./cyclomatic.js";
+
+export { LANGUAGE_TABLE, detectLanguageFromPath } from "./language-config.js";
+export type { LanguageConfig, SupportedLanguage } from "./language-config.js";

package/src/ast/language-config.ts

@@ -0,0 +1,231 @@
+/**
+ * Per-language tree-sitter node classification tables.
+ *
+ * Every language grammar exposes a different set of node type names. To
+ * keep the AST engine language-agnostic we encode, for each supported
+ * language, three sets:
+ *
+ *   - `functionNodeTypes`  — nodes that represent a function/method/lambda.
+ *                             These are the units we report metrics for.
+ *   - `branchingNodeTypes` — nodes that add one independent path through
+ *                             the function. Used to compute cyclomatic
+ *                             complexity by counting occurrences.
+ *   - `nameField`          — the tree-sitter field name that holds the
+ *                             function's identifier, used to extract the
+ *                             function name for reporting.
+ *
+ * We also define which WASM grammar file to load per language. The paths
+ * are resolved at runtime against the `tree-sitter-wasms` package, but
+ * can be overridden via the engine constructor if you want to ship your
+ * own grammars.
+ *
+ * @module ast/language-config
+ */
+
+/**
+ * Languages currently supported by the AST engine. This is the same
+ * `enum` that appears in the `analyze_file_ast` tool schema — keep them
+ * in sync when adding a new language.
+ */
+export type SupportedLanguage = "csharp" | "javascript" | "typescript" | "python" | "java";
+
+/**
+ * Per-language classification record. Immutable by convention.
+ */
+export interface LanguageConfig {
+  /** Canonical language identifier (stable across releases). */
+  readonly id: SupportedLanguage;
+  /** WASM grammar filename inside `tree-sitter-wasms/out/`. */
+  readonly wasmName: string;
+  /** File extensions that should map to this language. */
+  readonly extensions: ReadonlyArray<string>;
+  /** Tree-sitter node types that represent callable units. */
+  readonly functionNodeTypes: ReadonlySet<string>;
+  /** Tree-sitter node types that add +1 to cyclomatic complexity. */
+  readonly branchingNodeTypes: ReadonlySet<string>;
+  /**
+   * Boolean / short-circuit operator node types. These are counted only
+   * when the node is an `"&&"`, `"||"`, `"??"` (etc.) operator, so the
+   * walker inspects the operator text on top of the node type.
+   */
+  readonly booleanOperators: ReadonlyArray<string>;
+  /**
+   * Child-field names we try in order to extract the function name. The
+   * walker reads the first non-empty match.
+   */
+  readonly nameFieldCandidates: ReadonlyArray<string>;
+}
+
+// -----------------------------------------------------------------------------
+// C#
+// -----------------------------------------------------------------------------
+// Grammar: https://github.com/tree-sitter/tree-sitter-c-sharp
+const CSHARP: LanguageConfig = {
+  id: "csharp",
+  wasmName: "tree-sitter-c_sharp.wasm",
+  extensions: [".cs"],
+  functionNodeTypes: new Set([
+    "method_declaration",
+    "local_function_statement",
+    "lambda_expression",
+    "anonymous_method_expression",
+    "constructor_declaration",
+    "destructor_declaration",
+    "operator_declaration",
+    "conversion_operator_declaration",
+    "accessor_declaration",
+  ]),
+  branchingNodeTypes: new Set([
+    "if_statement",
+    "else_clause",
+    "while_statement",
+    "do_statement",
+    "for_statement",
+    "for_each_statement",
+    "case_switch_label",
+    "case_pattern_switch_label",
+    "switch_expression_arm",
+    "catch_clause",
+    "conditional_expression",
+    "conditional_access_expression",
+    "when_clause",
+  ]),
+  booleanOperators: ["&&", "||", "??"],
+  nameFieldCandidates: ["name"],
+};
+
+// -----------------------------------------------------------------------------
+// JavaScript
+// -----------------------------------------------------------------------------
+// Grammar: https://github.com/tree-sitter/tree-sitter-javascript
+const JAVASCRIPT: LanguageConfig = {
+  id: "javascript",
+  wasmName: "tree-sitter-javascript.wasm",
+  extensions: [".js", ".jsx", ".mjs", ".cjs"],
+  functionNodeTypes: new Set([
+    "function_declaration",
+    "function_expression",
+    "arrow_function",
+    "method_definition",
+    "generator_function",
+    "generator_function_declaration",
+  ]),
+  branchingNodeTypes: new Set([
+    "if_statement",
+    "else_clause",
+    "while_statement",
+    "do_statement",
+    "for_statement",
+    "for_in_statement",
+    "for_of_statement",
+    "switch_case",
+    "catch_clause",
+    "ternary_expression",
+  ]),
+  booleanOperators: ["&&", "||", "??"],
+  nameFieldCandidates: ["name"],
+};
+
+// -----------------------------------------------------------------------------
+// TypeScript
+// -----------------------------------------------------------------------------
+// Grammar: https://github.com/tree-sitter/tree-sitter-typescript
+// The TypeScript grammar inherits most node types from JavaScript, so we
+// extend the JS tables rather than re-declaring them from scratch.
+const TYPESCRIPT: LanguageConfig = {
+  id: "typescript",
+  wasmName: "tree-sitter-typescript.wasm",
+  extensions: [".ts", ".tsx", ".mts", ".cts"],
+  functionNodeTypes: new Set([
+    ...JAVASCRIPT.functionNodeTypes,
+    "function_signature",
+    "method_signature",
+    "abstract_method_signature",
+  ]),
+  branchingNodeTypes: new Set([...JAVASCRIPT.branchingNodeTypes]),
+  booleanOperators: [...JAVASCRIPT.booleanOperators],
+  nameFieldCandidates: ["name"],
+};
+
+// -----------------------------------------------------------------------------
+// Python
+// -----------------------------------------------------------------------------
+// Grammar: https://github.com/tree-sitter/tree-sitter-python
+const PYTHON: LanguageConfig = {
+  id: "python",
+  wasmName: "tree-sitter-python.wasm",
+  extensions: [".py", ".pyi"],
+  functionNodeTypes: new Set(["function_definition", "lambda"]),
+  branchingNodeTypes: new Set([
+    "if_statement",
+    "elif_clause",
+    "else_clause",
+    "while_statement",
+    "for_statement",
+    "try_statement",
+    "except_clause",
+    "conditional_expression",
+    "match_statement",
+    "case_clause",
+  ]),
+  booleanOperators: ["and", "or"],
+  nameFieldCandidates: ["name"],
+};
+
+// -----------------------------------------------------------------------------
+// Java
+// -----------------------------------------------------------------------------
+// Grammar: https://github.com/tree-sitter/tree-sitter-java
+const JAVA: LanguageConfig = {
+  id: "java",
+  wasmName: "tree-sitter-java.wasm",
+  extensions: [".java"],
+  functionNodeTypes: new Set([
+    "method_declaration",
+    "constructor_declaration",
+    "lambda_expression",
+  ]),
+  branchingNodeTypes: new Set([
+    "if_statement",
+    "while_statement",
+    "do_statement",
+    "for_statement",
+    "enhanced_for_statement",
+    "switch_label",
+    "switch_rule",
+    "catch_clause",
+    "ternary_expression",
+  ]),
+  booleanOperators: ["&&", "||"],
+  nameFieldCandidates: ["name"],
+};
+
+/**
+ * Complete language table. Look up by {@link SupportedLanguage} identifier.
+ */
+export const LANGUAGE_TABLE: Readonly<Record<SupportedLanguage, LanguageConfig>> = {
+  csharp: CSHARP,
+  javascript: JAVASCRIPT,
+  typescript: TYPESCRIPT,
+  python: PYTHON,
+  java: JAVA,
+};
+
+/**
+ * Infer a {@link SupportedLanguage} from a file path by matching its
+ * extension. Returns `null` when no known language matches. Useful when
+ * the caller does not already know the language and wants the engine to
+ * pick one automatically.
+ *
+ * @param filePath File path (absolute or relative).
+ * @returns        The detected language or `null`.
+ */
+export function detectLanguageFromPath(filePath: string): SupportedLanguage | null {
+  const lower = filePath.toLowerCase();
+  for (const config of Object.values(LANGUAGE_TABLE)) {
+    for (const ext of config.extensions) {
+      if (lower.endsWith(ext)) return config.id;
+    }
+  }
+  return null;
+}