@stupify/cli 0.0.15 → 0.1.0

package/dist/counter-scout.js

@@ -1,167 +0,0 @@
-const MAX_COUNTER_EXAMPLES_PER_CHECK = 20;
-export function counterScoutTargets(changeSet, checks, maxTargets) {
-    return counterScoutPlan(changeSet, checks, maxTargets).targets;
-}
-export function counterScoutPlan(changeSet, checks, maxTargets) {
-    const buckets = runSignalCounters(changeSet, checks);
-    const targets = [];
-    let cursor = 0;
-    while (targets.length < maxTargets && buckets.some((bucket) => cursor < bucket.examples.length)) {
-        for (const bucket of buckets) {
-            const signal = bucket.examples[cursor];
-            if (!signal)
-                continue;
-            targets.push({
-                sourceId: changeSet.id,
-                targetId: `t${String(targets.length + 1).padStart(3, "0")}`,
-                entityId: signal.entityId,
-                checkId: signal.checkId,
-                reason: signal.reasonCode,
-            });
-            if (targets.length >= maxTargets)
-                break;
-        }
-        cursor += 1;
-    }
-    return {
-        buckets,
-        totalSignals: buckets.reduce((sum, bucket) => sum + bucket.total, 0),
-        maxTargets,
-        targets,
-    };
-}
-export function runSignalCounters(changeSet, checks) {
-    return checks
-        .map((check) => {
-        const signals = changeSet.changes.flatMap((change) => {
-            const reasonCode = reasonForCheck(check.id, change);
-            return reasonCode ? [{ checkId: check.id, entityId: change.entityId, reasonCode }] : [];
-        });
-        return {
-            checkId: check.id,
-            total: signals.length,
-            examples: signals.slice(0, MAX_COUNTER_EXAMPLES_PER_CHECK),
-        };
-    })
-        .filter((bucket) => bucket.total > 0);
-}
-function reasonForCheck(checkId, change) {
-    if (!isSearchableSourceChange(change))
-        return null;
-    const haystack = `${change.entityName}\n${change.entityType}\n${change.filePath}\n${change.afterContent ?? ""}`.toLowerCase();
-    const changed = change.changeType === "added" || change.changeType === "modified";
-    if (!changed)
-        return null;
-    switch (checkId) {
-        case "duplicated_schema":
-            return isDuplicatedSchemaCandidate(change) ? "local_schemaish_copy" : null;
-        case "unnecessary_complexity":
-            return /\b(helper|wrapper|service|provider|manager|factory|adapter|resolver|coordinator)\b/i.test(change.entityName)
-                ? "new_abstraction_name"
-                : null;
-        case "fake_precision_windowing":
-            return /\b(token|budget|window|batch|ratio|estimate|counter|count|limit)\b/i.test(haystack)
-                ? "precision_accounting_terms"
-                : null;
-        case "coauthored_slop":
-            return /\b(coauhtoried|coauthored|co-authored|co-authored-by)\b/i.test(haystack)
-                ? "coauthor_text"
-                : null;
-        case "mega_file":
-            return change.entityType === "chunk" && /lines\s+\d+-\d+/i.test(change.entityName)
-                ? "large_changed_chunk"
-                : null;
-        case "over_commenting":
-            return overCommentingSignal(change)
-                ? "comment_lines_increased"
-                : null;
-        case "lint_bypass":
-            return lintBypassSignal(change.afterContent ?? "")
-                ? "lint_or_type_bypass_text"
-                : null;
-        case "inconsistent_patterns":
-            return /\b(manager|factory|provider|adapter|orchestrator|coordinator)\b/i.test(change.entityName)
-                ? "pattern_abstraction_name"
-                : null;
-        case "reinvented_utils":
-            return reinventedUtilitySignal(change)
-                ? "generic_utility_name"
-                : null;
-        case "operator_style_mismatch":
-            return /\b(manager|factory|provider|enterprise|orchestrator)\b/i.test(haystack)
-                ? "style_smell_terms"
-                : null;
-        default:
-            return null;
-    }
-}
-function isDuplicatedSchemaCandidate(change) {
-    if (!/^(interface|type)$/i.test(change.entityType))
-        return false;
-    if (/^(public|external|internal|payment|.+client$)/i.test(change.entityName))
-        return false;
-    return /\b(local|payload|schema)\b/i.test(words(change.entityName));
-}
-function overCommentingSignal(change) {
-    const before = commentLines(change.beforeContent);
-    const after = commentLines(change.afterContent);
-    if (after <= before + 3)
-        return false;
-    const comments = commentText(change.afterContent);
-    if (/\b(because|why|constraint|provider|external|api|quirk|edge case|timezone|utc|ledger|finance|reconciliation|rejects|mirrors|keep this)\b/i.test(comments)) {
-        return false;
-    }
-    return true;
-}
-function lintBypassSignal(value) {
-    return value.split(/\r?\n/).some((line) => {
-        const trimmed = line.trim();
-        const comment = /^(\/\/|\/\*|\*)/.test(trimmed);
-        if (comment && /@ts-ignore\s*$/i.test(trimmed))
-            return true;
-        if (comment && /@ts-expect-error\s*$/i.test(trimmed))
-            return true;
-        if (comment && /(eslint-disable|biome-ignore)/i.test(trimmed) && !/\s--\s*\S/.test(trimmed))
-            return true;
-        return /\bas unknown as\b|\bas any\b|:\s*any\b/i.test(trimmed);
-    });
-}
-function reinventedUtilitySignal(change) {
-    const name = change.entityName;
-    if (!/^(clamp|debounce|throttle|slug|slugify|sort|shuffle|memoize|pick|omit|uniq)/i.test(name))
-        return false;
-    const content = change.afterContent ?? "";
-    if (/currency|invoice|refund|subscription|tier|domain/i.test(`${name}\n${content}`))
-        return false;
-    return true;
-}
-function isSearchableSourceChange(change) {
-    const filePath = change.filePath.toLowerCase();
-    if (/(^|\/)(bun|package-lock|pnpm-lock|yarn)\.lock$/.test(filePath))
-        return false;
-    if (/(^|\/)(dist|build|coverage|generated|vendor|fixtures?|snapshots?)(\/|$)/.test(filePath))
-        return false;
-    if (/\.(md|mdx|txt|json|jsonc|ya?ml|toml|lock|csv|svg|png|jpe?g|gif|webp)$/i.test(filePath))
-        return false;
-    if (/\.(test|spec|fixture)\.[cm]?[jt]sx?$/i.test(filePath))
-        return false;
-    return /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts)$/i.test(filePath);
-}
-function commentLines(value) {
-    if (!value)
-        return 0;
-    return value.split(/\r?\n/).filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line)).length;
-}
-function commentText(value) {
-    if (!value)
-        return "";
-    return value
-        .split(/\r?\n/)
-        .filter((line) => /^\s*(\/\/|\/\*|\*|#)/.test(line))
-        .join("\n");
-}
-function words(value) {
-    return value
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .replace(/[_-]+/g, " ");
-}

package/dist/diff.d.ts

@@ -1 +0,0 @@
-export declare function readDiffFromStdin(): Promise<string>;

package/dist/diff.js

@@ -1,10 +0,0 @@
-import { stdin as input } from "node:process";
-export async function readDiffFromStdin() {
-    const chunks = [];
-    for await (const chunk of input)
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    const text = Buffer.concat(chunks).toString("utf8");
-    if (!text.trim())
-        throw new Error("No diff received on stdin.");
-    return text;
-}

package/dist/doctor.d.ts

@@ -1,4 +0,0 @@
-export declare function runDoctor(): Promise<Readonly<{
-    exitCode: number;
-    text: string;
-}>>;

package/dist/doctor.js

@@ -1,131 +0,0 @@
-import { execFile } from "node:child_process";
-import { createRequire } from "node:module";
-import { homedir, platform } from "node:os";
-import path from "node:path";
-import { promisify } from "node:util";
-import { DEFAULT_MODEL_ID, MODEL_REGISTRY } from "./constants.js";
-import { runHookCommand } from "./hooks.js";
-const execFileAsync = promisify(execFile);
-export async function runDoctor() {
-    const checks = await Promise.all([
-        gitCheck(),
-        hookCheck(),
-        semCheck(),
-        repomixCheck(),
-        llamaServerCheck(),
-        modelCacheCheck(),
-    ]);
-    const requiredMissing = checks.some((check) => check.required && check.status === "missing");
-    return {
-        exitCode: requiredMissing ? 1 : 0,
-        text: renderDoctor(checks),
-    };
-}
-async function gitCheck() {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { maxBuffer: 1024 * 1024 });
-        return { label: "git repo", status: "ok", detail: stdout.trim(), required: true };
-    }
-    catch {
-        return { label: "git repo", status: "missing", detail: "not inside a git repository", required: true };
-    }
-}
-async function hookCheck() {
-    try {
-        const status = await runHookCommand("status");
-        return { label: "pre-commit hook", status: "info", detail: status.replace(/^Stupify hook:\s*/, "") };
-    }
-    catch (error) {
-        return { label: "pre-commit hook", status: "info", detail: errorMessage(error) };
-    }
-}
-async function semCheck() {
-    const packageBin = resolvePackage("@ataraxy-labs/sem/bin/sem.js");
-    if (packageBin)
-        return { label: "sem", status: "ok", detail: "@ataraxy-labs/sem package binary found", required: true };
-    if (await commandExists("sem"))
-        return { label: "sem", status: "ok", detail: "sem found on PATH", required: true };
-    return { label: "sem", status: "missing", detail: "install @ataraxy-labs/sem or put sem on PATH", required: true };
-}
-async function repomixCheck() {
-    if (resolvePackage("repomix"))
-        return { label: "Repomix", status: "ok", detail: "repomix package found", required: true };
-    return { label: "Repomix", status: "missing", detail: "repomix package is not installed", required: true };
-}
-async function llamaServerCheck() {
-    if (await commandExists("llama-server"))
-        return { label: "llama-server", status: "ok", detail: "llama-server found on PATH", required: true };
-    return { label: "llama-server", status: "missing", detail: "install llama.cpp, for example `brew install llama.cpp`", required: true };
-}
-async function modelCacheCheck() {
-    const model = MODEL_REGISTRY[DEFAULT_MODEL_ID];
-    const modelPath = path.join(cacheDir(), "models", model.file);
-    if (await fileExists(modelPath))
-        return { label: "default model", status: "ok", detail: `${model.name} cached` };
-    return {
-        label: "default model",
-        status: "info",
-        detail: `${model.name} not cached yet; first interactive search can download it locally`,
-    };
-}
-function renderDoctor(checks) {
-    const lines = [
-        "Stupify doctor",
-        "",
-        ...checks.map((check) => `${icon(check.status)} ${check.label}: ${check.detail}`),
-        "",
-        "Privacy: local-only. Stupify does not upload source, diffs, filenames, repo URLs, commit messages, author names, or private package names.",
-    ];
-    return lines.join("\n");
-}
-function icon(status) {
-    if (status === "ok")
-        return "OK";
-    if (status === "missing")
-        return "MISSING";
-    return "INFO";
-}
-function resolvePackage(specifier) {
-    try {
-        const require = createRequire(import.meta.url);
-        return require.resolve(specifier);
-    }
-    catch {
-        return null;
-    }
-}
-async function commandExists(command) {
-    try {
-        await execFileAsync("sh", ["-c", `command -v ${shellQuote(command)}`], { maxBuffer: 1024 * 1024 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function fileExists(filePath) {
-    try {
-        const { stat } = await import("node:fs/promises");
-        return (await stat(filePath)).isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function cacheDir() {
-    if (process.env.STUPIFY_CACHE_DIR)
-        return process.env.STUPIFY_CACHE_DIR;
-    if (process.env.XDG_CACHE_HOME)
-        return path.join(process.env.XDG_CACHE_HOME, "stupify");
-    if (platform() === "darwin")
-        return path.join(homedir(), "Library", "Caches", "stupify");
-    if (platform() === "win32" && process.env.LOCALAPPDATA)
-        return path.join(process.env.LOCALAPPDATA, "stupify", "Cache");
-    return path.join(homedir(), ".cache", "stupify");
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/git.d.ts

@@ -1,12 +0,0 @@
-import { type NetDiff, type SourceRange, type StagedDiff } from "./types.ts";
-export declare function netDiffSince(since: string): Promise<NetDiff>;
-export declare function netDiffForCommit(commit: string): Promise<NetDiff>;
-export declare function netDiffForRecentCommits(count: number): Promise<NetDiff>;
-export declare function sourceRangeSince(since: string): Promise<SourceRange>;
-export declare function sourceRangeForCommit(commit: string): Promise<SourceRange>;
-export declare function sourceRangeForRecentCommits(count: number): Promise<SourceRange>;
-export declare function netDiffFromStdin(text: string): Promise<NetDiff>;
-export declare function stagedDiff(): Promise<StagedDiff>;
-export declare function gitRoot(): Promise<string>;
-export declare function gitPath(pathspec: string): Promise<string>;
-export declare function gitUserLabel(): Promise<string>;

package/dist/git.js

@@ -1,298 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { sourceId } from "./types.js";
-const execFileAsync = promisify(execFile);
-export async function netDiffSince(since) {
-    const range = await sourceRangeSince(since);
-    return netDiff(range.base, range.target, range.label, range.id);
-}
-export async function netDiffForCommit(commit) {
-    const range = await sourceRangeForCommit(commit);
-    return netDiff(range.base, range.target, range.label, range.id);
-}
-export async function netDiffForRecentCommits(count) {
-    const range = await sourceRangeForRecentCommits(count);
-    return netDiff(range.base, range.target, range.label, range.id);
-}
-export async function sourceRangeSince(since) {
-    const [base, target] = await Promise.all([baseBefore(since), revParse("HEAD")]);
-    return sourceRange(base, target, `last ${since}`);
-}
-export async function sourceRangeForCommit(commit) {
-    const [base, target, shortTarget, message] = await Promise.all([
-        revParse(`${commit}^1`),
-        revParse(commit),
-        shortCommit(commit),
-        commitMessage(commit),
-    ]);
-    return sourceRange(base, target, firstLine(message) || shortTarget, sourceId(shortTarget));
-}
-export async function sourceRangeForRecentCommits(count) {
-    const commits = await recentCommits(count);
-    if (commits.length === 0)
-        throw new Error("No non-merge commits found.");
-    const oldest = commits[0];
-    const newest = commits[commits.length - 1];
-    if (!oldest || !newest)
-        throw new Error("Could not resolve recent commit range.");
-    const [base, target, shortBase, shortTarget] = await Promise.all([
-        revParse(`${oldest}^1`),
-        revParse(newest),
-        shortCommit(`${oldest}^1`),
-        shortCommit(newest),
-    ]);
-    return sourceRange(base, target, `${commits.length} recent commits`, sourceId(`range:${shortBase}..${shortTarget}`));
-}
-export async function netDiffFromStdin(text) {
-    if (!text.trim())
-        throw new Error("No diff received on stdin.");
-    return {
-        id: sourceId("stdin"),
-        label: "stdin",
-        base: "stdin",
-        target: "stdin",
-        text,
-        stats: statsFromDiff(text),
-    };
-}
-export async function stagedDiff() {
-    try {
-        const { stdout } = await execFileAsync("git", [
-            "diff",
-            "--cached",
-            "--no-ext-diff",
-            "--no-color",
-            "--unified=3",
-            "--",
-        ], { maxBuffer: 64 * 1024 * 1024 });
-        return { text: stdout, stats: statsFromDiff(stdout) };
-    }
-    catch {
-        throw new Error("Could not read staged changes. Run stupify inside a git repository.");
-    }
-}
-export async function gitRoot() {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
-        return stdout.trim();
-    }
-    catch {
-        throw new Error("Could not find a git repository.");
-    }
-}
-export async function gitPath(pathspec) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--git-path", pathspec]);
-        return stdout.trim();
-    }
-    catch {
-        throw new Error(`Could not resolve git path: ${pathspec}`);
-    }
-}
-export async function gitUserLabel() {
-    const [name, email] = await Promise.all([
-        gitConfig("user.name"),
-        gitConfig("user.email"),
-    ]);
-    if (name && email)
-        return `${name} <${email}>`;
-    return name || email || "working tree";
-}
-async function netDiff(base, target, label, id) {
-    const [text, stats, shortBase, shortTarget] = await Promise.all([
-        diff(base, target),
-        diffStats(base, target),
-        shortCommit(base),
-        shortCommit(target),
-    ]);
-    return {
-        id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
-        label,
-        base,
-        target,
-        text,
-        stats,
-    };
-}
-async function sourceRange(base, target, label, id) {
-    const [stats, shortBase, shortTarget, committers] = await Promise.all([
-        diffStats(base, target),
-        shortCommit(base),
-        shortCommit(target),
-        committersForRange(base, target),
-    ]);
-    return {
-        id: id ?? sourceId(`net:${shortBase}..${shortTarget}`),
-        label,
-        base,
-        target,
-        committers,
-        stats,
-    };
-}
-async function gitConfig(key) {
-    try {
-        const { stdout } = await execFileAsync("git", ["config", "--get", key]);
-        return stdout.trim();
-    }
-    catch {
-        return "";
-    }
-}
-async function committersForRange(base, target) {
-    try {
-        const { stdout } = await execFileAsync("git", ["log", "--format=%cn <%ce>", `${base}..${target}`], {
-            maxBuffer: 4 * 1024 * 1024,
-        });
-        return uniqueLines(stdout);
-    }
-    catch {
-        return [];
-    }
-}
-function uniqueLines(value) {
-    const seen = new Set();
-    const lines = [];
-    for (const line of value.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed || seen.has(trimmed))
-            continue;
-        seen.add(trimmed);
-        lines.push(trimmed);
-    }
-    return lines;
-}
-async function baseBefore(since) {
-    try {
-        const { stdout } = await execFileAsync("git", [
-            "log",
-            "--first-parent",
-            "--before",
-            since,
-            "-1",
-            "--format=%H",
-        ]);
-        const commit = stdout.trim();
-        if (commit)
-            return commit;
-        return rootCommit();
-    }
-    catch {
-        throw new Error(`Could not resolve base commit before ${since}.`);
-    }
-}
-async function rootCommit() {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-list", "--max-parents=0", "HEAD"]);
-        return stdout.trim().split(/\r?\n/, 1)[0] ?? "";
-    }
-    catch {
-        throw new Error("Could not resolve repository root commit.");
-    }
-}
-async function diff(base, target) {
-    try {
-        const { stdout } = await execFileAsync("git", [
-            "diff",
-            "--no-ext-diff",
-            "--no-color",
-            "--unified=8",
-            base,
-            target,
-            "--",
-        ], { maxBuffer: 128 * 1024 * 1024 });
-        if (!stdout.trim())
-            throw new Error("empty diff");
-        return stdout;
-    }
-    catch {
-        throw new Error(`No diff found for ${base}..${target}.`);
-    }
-}
-async function diffStats(base, target) {
-    try {
-        const { stdout } = await execFileAsync("git", ["diff", "--numstat", base, target, "--"], {
-            maxBuffer: 16 * 1024 * 1024,
-        });
-        return statsFromNumstat(stdout);
-    }
-    catch {
-        return { filesChanged: 0, additions: 0, deletions: 0 };
-    }
-}
-function statsFromDiff(diffText) {
-    const files = new Set();
-    let additions = 0;
-    let deletions = 0;
-    for (const line of diffText.split(/\r?\n/)) {
-        const fileMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-        if (fileMatch?.[1])
-            files.add(fileMatch[1]);
-        else if (line.startsWith("+") && !line.startsWith("+++"))
-            additions += 1;
-        else if (line.startsWith("-") && !line.startsWith("---"))
-            deletions += 1;
-    }
-    return { filesChanged: files.size, additions, deletions };
-}
-function statsFromNumstat(numstat) {
-    let filesChanged = 0;
-    let additions = 0;
-    let deletions = 0;
-    for (const line of numstat.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const [added, deleted] = line.split(/\s+/, 3);
-        filesChanged += 1;
-        additions += Number(added) || 0;
-        deletions += Number(deleted) || 0;
-    }
-    return { filesChanged, additions, deletions };
-}
-async function recentCommits(count) {
-    try {
-        const { stdout } = await execFileAsync("git", [
-            "log",
-            "--first-parent",
-            "--no-merges",
-            "--format=%H",
-            `-${count}`,
-        ]);
-        return stdout.split(/\r?\n/).filter(Boolean).reverse();
-    }
-    catch {
-        throw new Error(`Could not read last ${count} commits.`);
-    }
-}
-async function revParse(rev) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", rev]);
-        return stdout.trim();
-    }
-    catch {
-        throw new Error(`Could not resolve ${rev}.`);
-    }
-}
-async function shortCommit(commit) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "--short", commit]);
-        return stdout.trim();
-    }
-    catch {
-        throw new Error(`Could not resolve commit ${commit}.`);
-    }
-}
-async function commitMessage(commit) {
-    try {
-        const { stdout } = await execFileAsync("git", ["show", "--no-patch", "--format=%B", commit], {
-            maxBuffer: 1024 * 1024,
-        });
-        return stdout;
-    }
-    catch {
-        throw new Error(`Could not read commit message for ${commit}.`);
-    }
-}
-function firstLine(value) {
-    return value.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
-}

package/dist/hooks.d.ts

@@ -1,3 +0,0 @@
-import type { HookAction } from "./types.ts";
-export declare function runHookCommand(action: HookAction): Promise<string>;
-export declare function hookSnippet(): string;