@stupify/cli 0.0.2 → 0.0.3

package/dist/repomix-provider.js

@@ -0,0 +1,145 @@
+import { mkdtemp, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { pack, setLogLevel } from "repomix";
+const MAX_PACK_FILE_SIZE_BYTES = 48 * 1024;
+const MAX_PACK_TOTAL_SIZE_BYTES = 128 * 1024;
+export function emptyContextPack() {
+    return {
+        provider: "repomix",
+        filePaths: [],
+        totalCharacters: 0,
+        totalTokens: 0,
+        text: "",
+    };
+}
+export async function repomixContextPack(cwd, contexts, changes) {
+    const filePaths = await candidateFilePaths(cwd, contexts, changes);
+    if (filePaths.length === 0) {
+        return emptyContextPack();
+    }
+    setLogLevel(-1);
+    const tempDir = await mkdtemp(path.join(tmpdir(), "stupify-repomix-"));
+    const outputPath = path.join(tempDir, "context.xml");
+    try {
+        const result = await pack([cwd], {
+            cwd,
+            input: { maxFileSize: MAX_PACK_FILE_SIZE_BYTES },
+            output: {
+                filePath: outputPath,
+                style: "xml",
+                parsableStyle: false,
+                fileSummary: false,
+                directoryStructure: false,
+                files: true,
+                removeComments: false,
+                removeEmptyLines: true,
+                compress: true,
+                topFilesLength: 0,
+                showLineNumbers: true,
+                truncateBase64: true,
+                copyToClipboard: false,
+                includeFullDirectoryStructure: false,
+                tokenCountTree: false,
+                git: {
+                    sortByChanges: false,
+                    sortByChangesMaxCommits: 1,
+                    includeDiffs: false,
+                    includeLogs: false,
+                    includeLogsCount: 1,
+                },
+            },
+            include: [],
+            ignore: {
+                useGitignore: true,
+                useDotIgnore: true,
+                useDefaultPatterns: true,
+                customPatterns: [],
+            },
+            security: { enableSecurityCheck: false },
+            tokenCount: { encoding: "o200k_base" },
+        }, () => undefined, {}, [...filePaths]);
+        return {
+            provider: "repomix",
+            filePaths,
+            totalCharacters: result.totalCharacters,
+            totalTokens: result.totalTokens,
+            text: await readFile(outputPath, "utf8"),
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export function entityContextsFromChanges(candidates, changes) {
+    const byEntityId = new Map(changes.map((change) => [change.entityId, change]));
+    return candidates.flatMap((candidate) => {
+        const change = byEntityId.get(candidate.entityId);
+        if (!change)
+            return [];
+        return [{
+                targetId: candidate.targetId,
+                entityId: change.entityId,
+                entityName: change.entityName,
+                entityKind: change.entityType,
+                changeKind: change.changeType,
+                checkId: candidate.checkId,
+                reason: candidate.reason,
+                filePath: change.filePath,
+                text: JSON.stringify({
+                    source: "sem diff",
+                    file: change.filePath,
+                    type: change.entityType,
+                    name: change.entityName,
+                    change: change.changeType,
+                    before: shortenCode(change.beforeContent),
+                    after: shortenCode(change.afterContent),
+                }, null, 2),
+            }];
+    });
+}
+async function candidateFilePaths(cwd, contexts, changes) {
+    const byEntityId = new Map(changes.map((change) => [change.entityId, change.filePath]));
+    const paths = contexts.flatMap((context) => context.filePath ?? byEntityId.get(context.entityId) ?? []);
+    const safePaths = [...new Set(paths)].filter(isSafeRelativeFilePath);
+    const selected = [];
+    let totalBytes = 0;
+    for (const filePath of safePaths) {
+        const bytes = await fileSize(cwd, filePath);
+        if (bytes === null || bytes > MAX_PACK_FILE_SIZE_BYTES)
+            continue;
+        if (totalBytes + bytes > MAX_PACK_TOTAL_SIZE_BYTES)
+            continue;
+        totalBytes += bytes;
+        selected.push(filePath);
+    }
+    return selected;
+}
+function isSafeRelativeFilePath(value) {
+    if (!value || path.isAbsolute(value))
+        return false;
+    const normalized = path.normalize(value);
+    return normalized !== "." && !normalized.startsWith("..") && !path.isAbsolute(normalized);
+}
+async function fileSize(cwd, filePath) {
+    try {
+        const fullPath = path.join(cwd, filePath);
+        if (!fullPath.startsWith(`${cwd}${path.sep}`))
+            return null;
+        const result = await stat(fullPath);
+        return result.isFile() ? result.size : null;
+    }
+    catch {
+        return null;
+    }
+}
+function shortenCode(value) {
+    if (!value)
+        return "(none)";
+    const lines = value.split(/\r?\n/);
+    const limit = 120;
+    if (lines.length <= limit)
+        return value;
+    return `${lines.slice(0, limit).join("\n")}
+[stupify: sem entity content shortened after ${limit} lines]`;
+}

package/dist/sem-provider.d.ts

@@ -0,0 +1,2 @@
+import type { AnalyzeCommand, SemChangeSet } from "./types.ts";
+export declare function semChangeSetForCommand(command: AnalyzeCommand): Promise<SemChangeSet>;

package/dist/sem-provider.js

@@ -0,0 +1,221 @@
+import { execFile, spawn } from "node:child_process";
+import { mkdtemp, realpath, rm } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { cachedJson, fingerprint } from "./cache.js";
+import { readDiffFromStdin } from "./diff.js";
+import { sourceRangeForCommit, sourceRangeForRecentCommits, sourceRangeSince, } from "./git.js";
+import { sourceId } from "./types.js";
+const execFileAsync = promisify(execFile);
+export async function semChangeSetForCommand(command) {
+    if (command.kind === "stdin")
+        return semChangeSetFromPatch(await readDiffFromStdin(), command.debugSem);
+    if (command.kind === "commit") {
+        const range = await sourceRangeForCommit(command.commit);
+        const raw = await cachedSemDiff(["diff", "--commit", command.commit, "--format", "json"], range, command.debugSem);
+        return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
+    }
+    const range = await semRangeForCommand(command);
+    const raw = await cachedSemDiff(["diff", "--from", range.base, "--to", range.target, "--format", "json"], range, command.debugSem);
+    return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
+}
+async function semRangeForCommand(command) {
+    if (command.kind === "since")
+        return sourceRangeSince(command.since);
+    if (command.kind === "commit")
+        return sourceRangeForCommit(command.commit);
+    if (command.kind === "commits")
+        return sourceRangeForRecentCommits(command.count);
+    throw new Error("sem engine cannot resolve stdin as a git range.");
+}
+async function semChangeSetFromPatch(patch, debugSem) {
+    if (!patch.trim())
+        throw new Error("No diff received on stdin.");
+    const raw = await cachedJson("sem-diff", fingerprint({
+        version: 1,
+        cwd: process.cwd(),
+        command: ["diff", "--patch", "--format", "json"],
+        patchHash: fingerprint(patch),
+    }), () => runSemWithInput(["diff", "--patch", "--format", "json"], patch, debugSem));
+    return {
+        ...normalizeSemDiff(raw, {
+            id: sourceId("stdin"),
+            label: "stdin",
+            base: "stdin",
+            target: "stdin",
+            stats: { filesChanged: 0, additions: 0, deletions: 0 },
+        }),
+        contextCwd: process.cwd(),
+        cleanup: async () => undefined,
+    };
+}
+async function cachedSemDiff(args, range, debugSem) {
+    return cachedJson("sem-diff", fingerprint({
+        version: 1,
+        cwd: process.cwd(),
+        args,
+        base: range.base,
+        target: range.target,
+    }), () => runSem(args, debugSem));
+}
+async function withContextWorkspace(changeSet, debugSem) {
+    const tempDir = await realpath(await mkdtemp(path.join(tmpdir(), "stupify-sem-context-")));
+    let worktreeAdded = false;
+    try {
+        await git(["worktree", "add", "--detach", tempDir, changeSet.target], debugSem);
+        worktreeAdded = true;
+        return {
+            ...changeSet,
+            contextCwd: tempDir,
+            cleanup: async () => cleanupWorktree(tempDir, worktreeAdded, debugSem),
+        };
+    }
+    catch (error) {
+        await cleanupWorktree(tempDir, worktreeAdded, debugSem);
+        throw error;
+    }
+}
+async function runSem(args, debugSem, cwd = process.cwd()) {
+    if (debugSem)
+        console.error(`sem ${args.join(" ")}`);
+    const { command, commandArgs } = resolveSemCommand(args);
+    try {
+        const { stdout, stderr } = await execFileAsync(command, commandArgs, {
+            cwd,
+            maxBuffer: 128 * 1024 * 1024,
+        });
+        if (debugSem && stderr.trim())
+            console.error(stderr.trim());
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`sem failed. Install @ataraxy-labs/sem and ensure its binary is downloaded.\n${message}`);
+    }
+}
+async function runSemWithInput(args, stdin, debugSem) {
+    if (debugSem)
+        console.error(`sem ${args.join(" ")}`);
+    const { command, commandArgs } = resolveSemCommand(args);
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, commandArgs, { stdio: ["pipe", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => reject(error));
+        child.on("close", (code) => {
+            const stderrText = Buffer.concat(stderr).toString("utf8");
+            if (debugSem && stderrText.trim())
+                console.error(stderrText.trim());
+            if (code !== 0) {
+                reject(new Error(`sem failed with exit code ${code}${stderrText ? `: ${stderrText.trim()}` : ""}`));
+                return;
+            }
+            try {
+                resolve(JSON.parse(Buffer.concat(stdout).toString("utf8")));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.stdin.end(stdin);
+    });
+}
+async function git(args, debugSem) {
+    if (debugSem)
+        console.error(`git ${args.join(" ")}`);
+    await execFileAsync("git", [...args], { maxBuffer: 128 * 1024 * 1024 });
+}
+async function cleanupWorktree(tempDir, worktreeAdded, debugSem) {
+    if (!worktreeAdded) {
+        await rm(tempDir, { recursive: true, force: true });
+        return;
+    }
+    try {
+        await git(["worktree", "remove", "--force", tempDir], debugSem);
+    }
+    catch {
+        await rm(tempDir, { recursive: true, force: true });
+        await git(["worktree", "prune"], debugSem).catch(() => undefined);
+    }
+}
+function resolveSemCommand(args) {
+    const packageBin = semPackageBin();
+    if (packageBin)
+        return { command: process.execPath, commandArgs: [packageBin, ...args] };
+    return { command: "sem", commandArgs: args };
+}
+function semPackageBin() {
+    try {
+        const require = createRequire(import.meta.url);
+        return require.resolve("@ataraxy-labs/sem/bin/sem.js");
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeSemDiff(value, range) {
+    if (!value || typeof value !== "object")
+        throw new Error("sem returned invalid diff JSON.");
+    const record = value;
+    const changes = Array.isArray(record.changes) ? record.changes.flatMap(normalizeSemChange) : [];
+    const summary = normalizeSemSummary(record.summary, changes);
+    return {
+        id: range.id,
+        label: range.label,
+        base: range.base,
+        target: range.target,
+        contextCwd: process.cwd(),
+        cleanup: async () => undefined,
+        changes,
+        summary,
+    };
+}
+function normalizeSemChange(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const record = value;
+    const entityId = stringValue(record.entityId);
+    const entityName = stringValue(record.entityName);
+    const entityType = stringValue(record.entityType);
+    const filePath = stringValue(record.filePath);
+    const changeType = stringValue(record.changeType);
+    if (!entityId || !entityName || !entityType || !filePath || !changeType)
+        return [];
+    return [{
+            entityId,
+            entityName,
+            entityType,
+            filePath,
+            changeType,
+            beforeContent: nullableString(record.beforeContent),
+            afterContent: nullableString(record.afterContent),
+        }];
+}
+function normalizeSemSummary(value, changes) {
+    const record = value && typeof value === "object" ? value : {};
+    return {
+        added: numberValue(record.added) ?? countByChange(changes, "added"),
+        deleted: numberValue(record.deleted) ?? countByChange(changes, "deleted"),
+        modified: numberValue(record.modified) ?? countByChange(changes, "modified"),
+        moved: numberValue(record.moved) ?? countByChange(changes, "moved"),
+        renamed: numberValue(record.renamed) ?? countByChange(changes, "renamed"),
+        fileCount: numberValue(record.fileCount) ?? new Set(changes.map((change) => change.filePath)).size,
+        total: numberValue(record.total) ?? changes.length,
+    };
+}
+function countByChange(changes, changeType) {
+    return changes.filter((change) => change.changeType === changeType).length;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function nullableString(value) {
+    return typeof value === "string" ? value : null;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/stupify.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<number>;