@stupify/cli 0.0.3 → 0.0.4

package/dist/experiment.js

@@ -1,225 +0,0 @@
-import { execFile } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-export async function runExperiment(configPath) {
-    const config = await readConfig(configPath);
-    const startedAt = new Date();
-    const outputDir = path.join(process.cwd(), "experiments", "results", `${safeSegment(config.name)}-${timestamp(startedAt)}`);
-    await mkdir(outputDir, { recursive: true });
-    const cwd = resolveCwd(config.cwd);
-    const cliPath = path.resolve(process.argv[1] ?? "packages/cli/dist/stupify.js");
-    const summaries = [];
-    for (const run of config.runs) {
-        const args = ensureJson([...config.baseCommand, ...run.args]);
-        const command = [process.execPath, cliPath, ...args].join(" ");
-        const summary = await runOneExperiment({
-            id: run.id,
-            args,
-            command,
-            cwd,
-            cliPath,
-            outputDir,
-        });
-        summaries.push(summary);
-        await writeFile(path.join(outputDir, "summary.json"), `${JSON.stringify({ name: config.name, cwd, runs: summaries }, null, 2)}\n`);
-    }
-    return outputDir;
-}
-async function readConfig(configPath) {
-    const fullPath = path.resolve(configPath);
-    const raw = await readFile(fullPath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.name)
-        throw new Error("Experiment config requires name.");
-    if (!Array.isArray(parsed.baseCommand))
-        throw new Error("Experiment config requires baseCommand array.");
-    if (!Array.isArray(parsed.runs))
-        throw new Error("Experiment config requires runs array.");
-    return {
-        name: parsed.name,
-        cwd: parsed.cwd,
-        baseCommand: parsed.baseCommand,
-        runs: parsed.runs,
-    };
-}
-async function runOneExperiment(input) {
-    const startedAt = Date.now();
-    try {
-        const { stdout, stderr } = await execFileAsync(process.execPath, [input.cliPath, ...input.args], {
-            cwd: input.cwd,
-            maxBuffer: 128 * 1024 * 1024,
-        });
-        if (stderr.trim()) {
-            await writeFile(path.join(input.outputDir, `${safeSegment(input.id)}.stderr.txt`), stderr);
-        }
-        await writeFile(path.join(input.outputDir, `${safeSegment(input.id)}.json`), stdout);
-        const report = JSON.parse(stdout);
-        const summary = summarizeReport(input.id, input.command, Date.now() - startedAt, report, []);
-        await writeFile(path.join(input.outputDir, `${safeSegment(input.id)}-findings.md`), findingsMarkdown(summary, report));
-        return summary;
-    }
-    catch (error) {
-        const details = errorDetails(error);
-        if (details.stdout)
-            await writeFile(path.join(input.outputDir, `${safeSegment(input.id)}.stdout.txt`), details.stdout);
-        if (details.stderr)
-            await writeFile(path.join(input.outputDir, `${safeSegment(input.id)}.stderr.txt`), details.stderr);
-        const summary = summarizeReport(input.id, input.command, Date.now() - startedAt, {}, [details.message]);
-        await writeFile(path.join(input.outputDir, `${safeSegment(input.id)}-findings.md`), findingsMarkdown(summary, {}));
-        return summary;
-    }
-}
-function summarizeReport(id, command, elapsedMs, report, errors) {
-    const run = objectValue(report.run);
-    const auditStats = objectValue(run.auditStats);
-    const traceEvents = arrayValue(run.traceEvents).map(objectValue);
-    const findings = arrayValue(report.findings).map(objectValue);
-    const targetPreview = arrayValue(run.debugTargets).map(objectValue).map(debugTargetRecord);
-    const contextPackEvents = traceEvents.filter((event) => event.name === "context.pack");
-    const auditBatchEvents = traceEvents.filter((event) => event.name === "audit.batch");
-    const auditInputTokens = auditBatchEvents.map((event) => detailNumber(event.detail, "input_tokens")).filter(isNumber);
-    return {
-        id,
-        command,
-        totalMs: numberValue(objectValue(run.timingsMs).total, elapsedMs),
-        entitiesScanned: numberValue(run.entitiesScanned, 0),
-        targets: numberValue(run.auditedCandidateCount, 0),
-        targetsByCheck: recordOfNumbers(run.targetsByCheck),
-        auditContext: stringValue(run.auditContext, "unknown"),
-        auditPrompt: stringValue(run.auditPrompt, "unknown"),
-        repomixFiles: maxNumber(contextPackEvents.map((event) => numberValue(event.count, 0))),
-        repomixTokens: maxNumber(contextPackEvents.map((event) => detailNumber(event.detail, "pack_tokens") ?? 0)),
-        auditCalls: auditBatchEvents.length,
-        auditInputTokens,
-        auditMs: numberValue(objectValue(run.timingsMs).audit, 0),
-        findings: findings.length,
-        uncertain: numberValue(auditStats.uncertain, 0),
-        clean: numberValue(auditStats.clean, 0),
-        findingsByCheck: countBy(findings, "checkId"),
-        uncertainByCheck: {},
-        targetPreview,
-        errors,
-    };
-}
-function findingsMarkdown(summary, report) {
-    const findings = arrayValue(report.findings).map(objectValue);
-    const lines = [
-        `# ${summary.id}`,
-        "",
-        `Runtime: ${Math.round(summary.totalMs / 1000)}s`,
-        `Targets: ${summary.targets}`,
-        `Findings: ${summary.findings}`,
-        `Uncertain: ${summary.uncertain}`,
-        "",
-        "## Targets",
-        ...targetMarkdown(summary.targetPreview),
-        "",
-        "## Findings",
-    ];
-    if (findings.length === 0) {
-        lines.push("None.");
-    }
-    else {
-        findings.forEach((finding, index) => {
-            lines.push(`${index + 1}. ${stringValue(finding.checkId, "unknown")}`, `why: ${stringValue(finding.why, "")}`, `proof: ${stringValue(finding.proof, "")}`, "Manual label: [good/maybe/bad]", "");
-        });
-    }
-    if (summary.errors.length > 0) {
-        lines.push("", "## Errors", ...summary.errors.map((error) => `- ${error}`));
-    }
-    return `${lines.join("\n")}\n`;
-}
-function targetMarkdown(targets) {
-    if (targets.length === 0)
-        return ["None recorded."];
-    return targets.map((target) => (`- ${target.targetId} ${target.checkId} ${target.entityKind ?? "unknown"}/${target.changeKind ?? "unknown"} ${target.entityId}
-  reason: ${target.scoutReason ?? ""}`));
-}
-function countBy(items, key) {
-    const counts = {};
-    for (const item of items) {
-        const value = stringValue(item[key], "");
-        if (!value)
-            continue;
-        counts[value] = (counts[value] ?? 0) + 1;
-    }
-    return counts;
-}
-function recordOfNumbers(value) {
-    const input = objectValue(value);
-    const output = {};
-    for (const [key, count] of Object.entries(input)) {
-        if (typeof count === "number" && Number.isFinite(count))
-            output[key] = count;
-    }
-    return output;
-}
-function debugTargetRecord(value) {
-    return {
-        targetId: stringValue(value.targetId, ""),
-        checkId: stringValue(value.checkId, ""),
-        entityId: stringValue(value.entityId, ""),
-        entityKind: optionalString(value.entityKind),
-        changeKind: optionalString(value.changeKind),
-        scoutReason: optionalString(value.scoutReason),
-        sourceLabel: optionalString(value.sourceLabel),
-    };
-}
-function optionalString(value) {
-    return typeof value === "string" ? value : undefined;
-}
-function ensureJson(args) {
-    return args.includes("--json") ? args : [...args, "--json"];
-}
-function resolveCwd(value) {
-    if (!value)
-        return process.cwd();
-    if (value.startsWith("$")) {
-        const envName = value.slice(1);
-        const envValue = process.env[envName];
-        if (!envValue)
-            throw new Error(`Experiment cwd env var ${envName} is not set.`);
-        return path.resolve(envValue);
-    }
-    return path.resolve(value);
-}
-function objectValue(value) {
-    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function arrayValue(value) {
-    return Array.isArray(value) ? value : [];
-}
-function stringValue(value, fallback) {
-    return typeof value === "string" ? value : fallback;
-}
-function numberValue(value, fallback) {
-    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-function detailNumber(value, key) {
-    if (typeof value !== "string")
-        return null;
-    const match = new RegExp(`${key}=([0-9]+)`).exec(value);
-    return match ? Number(match[1]) : null;
-}
-function maxNumber(values) {
-    return values.length === 0 ? 0 : Math.max(...values);
-}
-function isNumber(value) {
-    return value !== null;
-}
-function errorDetails(error) {
-    const candidate = objectValue(error);
-    return {
-        message: error instanceof Error ? error.message : String(error),
-        stdout: typeof candidate.stdout === "string" ? candidate.stdout : undefined,
-        stderr: typeof candidate.stderr === "string" ? candidate.stderr : undefined,
-    };
-}
-function timestamp(date) {
-    return date.toISOString().replace(/[:.]/g, "-");
-}
-function safeSegment(value) {
-    return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "experiment";
-}

package/src/batcher.ts

@@ -1,198 +0,0 @@
-import type { DiffBatch, DiffHunk } from "./types.ts";
-
-const DEFAULT_BATCH_LINES = 1_000;
-
-type ParsedHunk = Readonly<{
-  fileId: string;
-  hunkId: string;
-  filePath: string;
-  text: string;
-  lineCount: number;
-}>;
-
-export function batchDiff(
-  diff: string,
-  linesPerBatch = DEFAULT_BATCH_LINES,
-): readonly DiffBatch[] {
-  const hunks = parseHunks(diff).flatMap((item) =>
-    splitLargeHunk(item, linesPerBatch),
-  );
-
-  type BatchState = Readonly<{
-    batches: readonly DiffBatch[];
-    current: readonly DiffHunk[];
-    currentLines: number;
-    batchNumber: number;
-  }>;
-
-  const initialState: BatchState = {
-    batches: [],
-    current: [],
-    currentLines: 0,
-    batchNumber: 1,
-  };
-
-  const finalized = hunks.reduce<BatchState>((state, hunk) => {
-    const needsFlush =
-      state.current.length > 0 &&
-      state.currentLines + hunk.lineCount > linesPerBatch;
-
-    const flushed = needsFlush ? flush(state) : state;
-    return {
-      ...flushed,
-      current: [...flushed.current, toDiffHunk(hunk, flushed.batchNumber)],
-      currentLines: flushed.currentLines + hunk.lineCount,
-    };
-  }, initialState);
-
-  return finalized.current.length > 0
-    ? [...finalized.batches, toBatch(finalized.batchNumber, finalized.current)]
-    : finalized.batches;
-
-  function flush(state: BatchState): BatchState {
-    return {
-      batches: [...state.batches, toBatch(state.batchNumber, state.current)],
-      current: [],
-      currentLines: 0,
-      batchNumber: state.batchNumber + 1,
-    };
-  }
-}
-
-export function allHunks(batches: readonly DiffBatch[]): readonly DiffHunk[] {
-  return batches.flatMap((batch) => batch.hunks);
-}
-
-function parseHunks(diff: string): readonly ParsedHunk[] {
-  type ParseState = Readonly<{
-    hunks: readonly ParsedHunk[];
-    filePath: string;
-    fileIndex: number;
-    hunkIndex: number;
-    fileHeader: readonly string[];
-    hunkLines: readonly string[] | null;
-  }>;
-
-  const lines = diff.split(/\r?\n/);
-
-  const initialState: ParseState = {
-    hunks: [],
-    filePath: "unknown",
-    fileIndex: 0,
-    hunkIndex: 0,
-    fileHeader: [],
-    hunkLines: null,
-  };
-
-  const finalState = lines.reduce<ParseState>((state, line) => {
-    const fileMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-    if (fileMatch) {
-      const flushed = flush(state);
-      return {
-        ...flushed,
-        fileIndex: flushed.fileIndex + 1,
-        hunkIndex: 0,
-        filePath: fileMatch[1],
-        fileHeader: [line],
-        hunkLines: null,
-      };
-    }
-
-    if (line.startsWith("@@ ")) {
-      const flushed = flush(state);
-      return {
-        ...flushed,
-        hunkIndex: flushed.hunkIndex + 1,
-        hunkLines: [...flushed.fileHeader, line],
-      };
-    }
-
-    if (state.hunkLines) return { ...state, hunkLines: [...state.hunkLines, line] };
-    if (state.fileHeader.length > 0) return { ...state, fileHeader: [...state.fileHeader, line] };
-    return state;
-  }, initialState);
-
-  return flush(finalState).hunks;
-
-  function flush(state: ParseState): ParseState {
-    if (!state.hunkLines) return state;
-    const fileId = `file-${pad(state.fileIndex)}`;
-    const hunkId = `hunk-${pad(state.hunkIndex)}`;
-    const text = state.hunkLines.join("\n").trimEnd();
-    const nextHunk: ParsedHunk = {
-      fileId,
-      hunkId,
-      filePath: state.filePath,
-      text,
-      lineCount: countLines(text),
-    };
-
-    return { ...state, hunks: [...state.hunks, nextHunk], hunkLines: null };
-  }
-}
-
-function splitLargeHunk(
-  hunk: ParsedHunk,
-  linesPerBatch: number,
-): readonly ParsedHunk[] {
-  if (hunk.lineCount <= linesPerBatch) return [hunk];
-  const lines = hunk.text.split(/\r?\n/);
-  const chunkCount = Math.ceil(lines.length / linesPerBatch);
-  return Array.from({ length: chunkCount }, (_, chunkIndex) => {
-    const start = chunkIndex * linesPerBatch;
-    const text = lines.slice(start, start + linesPerBatch).join("\n");
-    return {
-      ...hunk,
-      hunkId: `${hunk.hunkId}-part-${pad(chunkIndex + 1)}`,
-      text,
-      lineCount: countLines(text),
-    };
-  });
-}
-
-function toDiffHunk(hunk: ParsedHunk, batchNumber: number): DiffHunk {
-  const batchId = `batch-${pad(batchNumber)}`;
-  return {
-    ...hunk,
-    batchId,
-    pointer: `${batchId}:${hunk.fileId}:${hunk.hunkId}`,
-  };
-}
-
-function toBatch(batchNumber: number, hunks: readonly DiffHunk[]): DiffBatch {
-  const id = `batch-${pad(batchNumber)}`;
-  return {
-    id,
-    hunks,
-    text: hunks.map(formatHunkForSearch).join("\n\n"),
-  };
-}
-
-function formatHunkForSearch(hunk: DiffHunk): string {
-  return `POINTER ${hunk.pointer}
-FILE ${hunk.fileId}
-PATH ${hunk.filePath}
-${searchView(hunk.text)}`;
-}
-
-function searchView(text: string): string {
-  return text
-    .split(/\r?\n/)
-    .filter(
-      (line) =>
-        line.startsWith("diff --git ") ||
-        line.startsWith("--- ") ||
-        line.startsWith("+++ ") ||
-        line.startsWith("@@ ") ||
-        (line.startsWith("+") && !line.startsWith("+++")),
-    )
-    .join("\n");
-}
-
-function countLines(value: string): number {
-  return value.length === 0 ? 0 : value.split(/\r?\n/).length;
-}
-
-function pad(value: number): string {
-  return String(value).padStart(3, "0");
-}

package/src/candidate-context.ts

@@ -1,43 +0,0 @@
-import { allHunks } from "./batcher.ts";
-import type { CandidateContext, DiffBatch, DiffHunk } from "./types.ts";
-
-const MAX_CONTEXT_LINES = 80;
-
-export function candidateContexts(
-  batches: readonly DiffBatch[],
-  candidatePointers: readonly string[],
-): readonly CandidateContext[] {
-  const hunks = allHunks(batches);
-  const byPointer = new Map(hunks.map((hunk) => [hunk.pointer, hunk]));
-  const uniquePointers = [...new Set(candidatePointers)]
-    .sort((left, right) => hunkPriority(byPointer.get(right)) - hunkPriority(byPointer.get(left)));
-
-  return uniquePointers.flatMap((pointer) => {
-    const hunk = byPointer.get(pointer);
-    if (!hunk) return [];
-    return [{ pointer, text: formatHunk(hunk) }];
-  });
-}
-
-function formatHunk(hunk: DiffHunk): string {
-  return `PATH ${hunk.filePath}
-${shorten(hunk.text)}`;
-}
-
-function shorten(text: string): string {
-  const lines = text.split(/\r?\n/);
-  if (lines.length <= MAX_CONTEXT_LINES) return text;
-  return `${lines.slice(0, MAX_CONTEXT_LINES).join("\n")}
-[stupify: hunk shortened after ${MAX_CONTEXT_LINES} lines]`;
-}
-
-function hunkPriority(hunk: DiffHunk | undefined): number {
-  if (!hunk) return 0;
-  const text = hunk.text;
-  let priority = 0;
-  if (/^\+export\s+type\s|\+export\s+interface\s|\+type\s|\+interface\s/m.test(text)) priority += 3;
-  if (/^\+export\s+function\s|\+function\s/m.test(text)) priority += 2;
-  if (/\.map\(|=>\s*\(\{|=>\s*\{/m.test(text)) priority += 2;
-  if (/payload|schema|dto|response|result/i.test(text)) priority += 1;
-  return priority;
-}