@sean.holung/minicode 0.3.9 → 0.3.11

package/dist/src/benchmark/config.js

@@ -0,0 +1,197 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import dotenv from "dotenv";
+const DEFAULT_COMMAND_DENYLIST = [
+    /\brm\s+-rf\s+\//i,
+    /\bmkfs\b/i,
+    /\bdd\s+if=/i,
+    /:\(\)\s*\{\s*:\|:&\s*\};:/,
+    /\bshutdown\b/i,
+    /\breboot\b/i,
+    /\bpoweroff\b/i,
+    /\binit\s+0\b/i,
+    /\bchmod\s+-R\s+777\s+\//i,
+];
+const VALID_REASONING_EFFORTS = new Set([
+    "xhigh",
+    "high",
+    "medium",
+    "low",
+    "minimal",
+    "none",
+]);
+function parseNumber(value, fallback) {
+    if (value === undefined || value === "") {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+function parseBoolean(value, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(normalized)) {
+        return true;
+    }
+    if (["0", "false", "no", "off"].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+function parseReasoningEffort(value) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    return VALID_REASONING_EFFORTS.has(normalized) ? normalized : undefined;
+}
+function parseModelProvider(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "openai-compatible" ||
+        normalized === "openai" ||
+        normalized === "lmstudio" ||
+        normalized === "lm-studio") {
+        return "openai-compatible";
+    }
+    return "anthropic";
+}
+function parseCommandDenylistEnv(value) {
+    if (!value?.trim()) {
+        return [];
+    }
+    const trimmed = value.trim();
+    const toRegexps = (patterns) => patterns.flatMap((pattern) => {
+        try {
+            return [new RegExp(pattern, "i")];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (trimmed.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) {
+                return toRegexps(parsed);
+            }
+        }
+        catch {
+            return [];
+        }
+    }
+    return toRegexps(trimmed.split(",").map((pattern) => pattern.trim()).filter(Boolean));
+}
+async function readOptionalFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function getDefaultBenchmarkConfigPath(cwd = process.cwd()) {
+    return path.resolve(cwd, "benchmarks", "benchmark.config.json");
+}
+async function loadBenchmarkConfigFile(configPath) {
+    const file = await readOptionalFile(configPath);
+    if (!file) {
+        return {};
+    }
+    return JSON.parse(file);
+}
+export async function resolveBenchmarkEnv(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const configPath = options.configPath
+        ? path.resolve(cwd, options.configPath)
+        : getDefaultBenchmarkConfigPath(cwd);
+    const envFiles = (options.envFiles ?? []).map((filePath) => path.resolve(cwd, filePath));
+    const values = {};
+    for (const envFile of envFiles) {
+        const file = await readFile(envFile, "utf8");
+        Object.assign(values, dotenv.parse(file));
+    }
+    for (const [key, value] of Object.entries(options.env ?? process.env)) {
+        if (value !== undefined) {
+            values[key] = value;
+        }
+    }
+    return {
+        values,
+        configPath,
+        envFiles,
+    };
+}
+export async function buildBenchmarkAgentConfig(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const resolvedEnv = await resolveBenchmarkEnv(options);
+    const fileConfig = await loadBenchmarkConfigFile(resolvedEnv.configPath);
+    const overrides = options.overrides ?? {};
+    const provider = parseModelProvider(overrides.provider ??
+        resolvedEnv.values.MODEL_PROVIDER ??
+        fileConfig.modelProvider ??
+        "openai-compatible");
+    const openAiBaseUrl = overrides.baseUrl ??
+        resolvedEnv.values.OPENAI_BASE_URL ??
+        fileConfig.openAiBaseUrl ??
+        "http://localhost:1234/v1";
+    const model = overrides.model ??
+        resolvedEnv.values.MODEL ??
+        fileConfig.model ??
+        "";
+    const rawWorkspaceRoot = overrides.workspaceRoot ??
+        resolvedEnv.values.WORKSPACE_ROOT ??
+        fileConfig.workspaceRoot ??
+        cwd;
+    const workspaceRoot = path.resolve(cwd, rawWorkspaceRoot);
+    const isOpenRouter = provider === "openai-compatible" &&
+        openAiBaseUrl.toLowerCase().includes("openrouter");
+    const openAiApiKey = provider === "openai-compatible"
+        ? (isOpenRouter
+            ? (resolvedEnv.values.OPENROUTER_API_KEY ?? resolvedEnv.values.OPENAI_API_KEY)
+            : resolvedEnv.values.OPENAI_API_KEY)
+        : undefined;
+    return {
+        modelProvider: provider,
+        model,
+        maxSteps: parseNumber(resolvedEnv.values.MAX_STEPS ?? fileConfig.maxSteps, 50),
+        maxTokens: parseNumber(resolvedEnv.values.MAX_TOKENS ?? fileConfig.maxTokens, 4096),
+        modelTimeoutSeconds: parseNumber(resolvedEnv.values.MODEL_TIMEOUT_SECONDS ?? fileConfig.modelTimeoutSeconds, 60),
+        maxContextTokens: parseNumber(resolvedEnv.values.MAX_CONTEXT_TOKENS ?? fileConfig.maxContextTokens, 32_000),
+        workspaceRoot,
+        commandTimeoutMs: parseNumber(resolvedEnv.values.COMMAND_TIMEOUT_MS ?? fileConfig.commandTimeoutMs, 30_000),
+        maxFileSizeBytes: parseNumber(resolvedEnv.values.MAX_FILE_SIZE_BYTES ?? fileConfig.maxFileSizeBytes, 1_000_000),
+        commandDenylist: [
+            ...DEFAULT_COMMAND_DENYLIST,
+            ...parseCommandDenylistEnv(resolvedEnv.values.COMMAND_DENYLIST),
+        ],
+        confirmDestructive: parseBoolean(resolvedEnv.values.CONFIRM_DESTRUCTIVE ?? fileConfig.confirmDestructive, false),
+        keepRecentMessages: parseNumber(resolvedEnv.values.KEEP_RECENT_MESSAGES ?? fileConfig.keepRecentMessages, 12),
+        loopDetectionWindow: parseNumber(resolvedEnv.values.LOOP_DETECTION_WINDOW ?? fileConfig.loopDetectionWindow, 6),
+        maxToolOutputChars: parseNumber(resolvedEnv.values.MAX_TOOL_OUTPUT_CHARS ?? fileConfig.maxToolOutputChars, 8_000),
+        openAiBaseUrl,
+        ...(openAiApiKey !== undefined ? { openAiApiKey } : {}),
+        enableFileReadDedup: parseBoolean(resolvedEnv.values.ENABLE_FILE_READ_DEDUP ?? fileConfig.enableFileReadDedup, true),
+        enableAdaptiveKeepRecent: parseBoolean(resolvedEnv.values.ENABLE_ADAPTIVE_KEEP_RECENT ?? fileConfig.enableAdaptiveKeepRecent, true),
+        enableToolOutputTruncation: parseBoolean(resolvedEnv.values.ENABLE_TOOL_OUTPUT_TRUNCATION ?? fileConfig.enableToolOutputTruncation, true),
+        compactionThreshold: parseNumber(resolvedEnv.values.COMPACTION_THRESHOLD ?? fileConfig.compactionThreshold, 0.8),
+        ...(resolvedEnv.values.COMPACTION_MODEL ?? fileConfig.compactionModel
+            ? {
+                compactionModel: resolvedEnv.values.COMPACTION_MODEL ?? fileConfig.compactionModel ?? "",
+            }
+            : {}),
+        ...(() => {
+            const effort = parseReasoningEffort(resolvedEnv.values.REASONING_EFFORT ?? fileConfig.reasoningEffort);
+            return effort ? { reasoningEffort: effort } : {};
+        })(),
+        enableDynamicPrompt: parseBoolean(resolvedEnv.values.ENABLE_DYNAMIC_PROMPT ?? fileConfig.enableDynamicPrompt, false),
+    };
+}

package/dist/src/benchmark/index.js

@@ -1,4 +1,6 @@
 export { loadBenchmarkTask, loadBenchmarkTasks } from "./task-loader.js";
 export { evaluate } from "./evaluator.js";
 export { runBenchmarkTask, runBenchmarkSuite, } from "./runner.js";
+export { buildBenchmarkAgentConfig, getDefaultBenchmarkConfigPath, resolveBenchmarkEnv, } from "./config.js";
+export { collectWorkspaceChanges, writeWorkspaceDiff, } from "./workspace-changes.js";
 export { buildReport, buildReportFromEvaluations, formatReport, compareReports, } from "./reporter.js";

package/dist/src/benchmark/workspace-changes.js

@@ -0,0 +1,125 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+async function runGit(workspaceRoot, args, allowFailure = false) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", workspaceRoot, ...args], {
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch (error) {
+        if (allowFailure) {
+            const stdout = error.stdout;
+            if (typeof stdout === "string") {
+                return stdout;
+            }
+            return "";
+        }
+        throw error;
+    }
+}
+function parseStatusLine(line) {
+    if (line.length < 4) {
+        return undefined;
+    }
+    const status = line.slice(0, 2);
+    const rawPath = line.slice(3).trim();
+    if (!rawPath) {
+        return undefined;
+    }
+    if (rawPath.includes(" -> ")) {
+        const [previousPath, nextPath] = rawPath.split(" -> ");
+        if (!nextPath || !previousPath) {
+            return undefined;
+        }
+        return {
+            status,
+            path: nextPath,
+            previousPath,
+        };
+    }
+    return {
+        status,
+        path: rawPath,
+    };
+}
+async function isGitRepository(workspaceRoot) {
+    try {
+        const output = await runGit(workspaceRoot, ["rev-parse", "--is-inside-work-tree"], true);
+        return output.trim() === "true";
+    }
+    catch {
+        return false;
+    }
+}
+async function getWorkspaceGitPrefix(workspaceRoot) {
+    const prefix = await runGit(workspaceRoot, ["rev-parse", "--show-prefix"], true);
+    return prefix.trim();
+}
+function stripWorkspacePrefix(filePath, workspacePrefix) {
+    if (!workspacePrefix) {
+        return filePath;
+    }
+    const normalizedPrefix = workspacePrefix.endsWith("/")
+        ? workspacePrefix
+        : `${workspacePrefix}/`;
+    return filePath.startsWith(normalizedPrefix)
+        ? filePath.slice(normalizedPrefix.length)
+        : filePath;
+}
+export async function collectWorkspaceChanges(workspaceRoot) {
+    const isGitRepo = await isGitRepository(workspaceRoot);
+    if (!isGitRepo) {
+        return {
+            isGitRepo: false,
+            entries: [],
+            changedFiles: [],
+        };
+    }
+    const workspacePrefix = await getWorkspaceGitPrefix(workspaceRoot);
+    const statusOutput = await runGit(workspaceRoot, ["status", "--porcelain=v1", "--untracked-files=all", "--", "."], true);
+    const entries = statusOutput
+        .split(/\r?\n/)
+        .map((line) => parseStatusLine(line))
+        .map((entry) => entry
+        ? {
+            ...entry,
+            path: stripWorkspacePrefix(entry.path, workspacePrefix),
+            ...(entry.previousPath
+                ? { previousPath: stripWorkspacePrefix(entry.previousPath, workspacePrefix) }
+                : {}),
+        }
+        : undefined)
+        .filter((entry) => entry !== undefined);
+    const changedFiles = [...new Set(entries.map((entry) => entry.path))];
+    return {
+        isGitRepo: true,
+        entries,
+        changedFiles,
+    };
+}
+export async function writeWorkspaceDiff(workspaceRoot, outPath) {
+    const changes = await collectWorkspaceChanges(workspaceRoot);
+    if (!changes.isGitRepo) {
+        return false;
+    }
+    const trackedDiff = await runGit(workspaceRoot, ["diff", "--binary", "--no-ext-diff", "--relative", "--", "."], true);
+    const untrackedDiffs = [];
+    for (const entry of changes.entries) {
+        if (entry.status === "??") {
+            const diff = await runGit(workspaceRoot, ["diff", "--binary", "--no-ext-diff", "--no-index", "--", "/dev/null", entry.path], true);
+            if (diff.trim().length > 0) {
+                untrackedDiffs.push(diff);
+            }
+        }
+    }
+    const combinedDiff = [trackedDiff, ...untrackedDiffs]
+        .filter((section) => section.trim().length > 0)
+        .join("\n");
+    await mkdir(path.dirname(outPath), { recursive: true });
+    await writeFile(outPath, combinedDiff, "utf8");
+    return true;
+}

package/dist/src/cli/args.js

@@ -6,6 +6,19 @@ export class CliUsageError extends Error {
 }
 export function parseCliArgs(argv) {
     const args = argv.slice(2);
+    if (args[0] === "benchmark" && args[1] === "run") {
+        return {
+            verbose: false,
+            oneshot: false,
+            json: false,
+            serve: false,
+            port: 4567,
+            task: "",
+            pluginInstall: false,
+            benchmarkRun: true,
+            benchmarkArgv: args.slice(2),
+        };
+    }
     let verbose = false;
     let oneshot = false;
     let json = false;