@stupify/cli 0.0.15 → 0.1.0

package/dist/search-profile.js

@@ -1,73 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { defaultChecks, searchChecks } from "./checks.js";
-export async function loadSearchProfile(profilePath) {
-    if (!profilePath)
-        return null;
-    const fullPath = path.resolve(profilePath);
-    const value = JSON.parse(await readFile(fullPath, "utf8"));
-    if (!value || typeof value !== "object" || typeof value.id !== "string" || value.id.length === 0) {
-        throw new Error(`Invalid search profile: ${profilePath}`);
-    }
-    return value;
-}
-export function effectiveSearchChecks(explicitCheckIds, profile) {
-    const checks = explicitCheckIds
-        ? searchChecks(explicitCheckIds)
-        : profilePatternIds(profile).length > 0
-            ? checksById(profilePatternIds(profile))
-            : searchChecks(null);
-    if (!profile?.patterns)
-        return checks;
-    return checks.map((check) => applyPatternOverride(check, profile.patterns?.[check.id]));
-}
-export function effectiveMaxCandidates(defaultValue, profile) {
-    return positiveInteger(profile?.maxCandidates) ?? defaultValue;
-}
-export function effectiveMaxSearchInputTokens(defaultValue, profile) {
-    return positiveInteger(profile?.maxSearchInputTokens) ?? defaultValue;
-}
-export function effectiveRepomixConfig(defaultValue, profile) {
-    const override = profile?.repomix;
-    if (!override)
-        return defaultValue;
-    return {
-        compress: override.compress ?? defaultValue.compress,
-        showLineNumbers: override.showLineNumbers ?? defaultValue.showLineNumbers,
-        removeEmptyLines: override.removeEmptyLines ?? defaultValue.removeEmptyLines,
-        maxFileSizeBytes: positiveInteger(override.maxFileBytes) ?? defaultValue.maxFileSizeBytes,
-        maxTotalSizeBytes: positiveInteger(override.maxTotalBytes) ?? defaultValue.maxTotalSizeBytes,
-        ignorePatterns: override.ignorePatterns ?? defaultValue.ignorePatterns,
-    };
-}
-function profilePatternIds(profile) {
-    if (!profile?.patterns)
-        return [];
-    return Object.entries(profile.patterns)
-        .filter(([, pattern]) => pattern.enabled === true)
-        .map(([id]) => id);
-}
-function checksById(ids) {
-    const byId = new Map(defaultChecks.map((check) => [check.id, check]));
-    return ids.map((id) => {
-        const check = byId.get(id);
-        if (!check)
-            throw new Error(`Unknown check in search profile: ${id}`);
-        return check;
-    });
-}
-function applyPatternOverride(check, override) {
-    if (!override)
-        return check;
-    return {
-        ...check,
-        searchPrompt: override.searchPrompt ?? check.searchPrompt,
-        searchExamples: {
-            match: override.matchExamples ?? check.searchExamples?.match ?? check.examples?.match ?? [],
-            nonMatch: override.nonMatchExamples ?? check.searchExamples?.nonMatch ?? check.examples?.noMatch ?? [],
-        },
-    };
-}
-function positiveInteger(value) {
-    return Number.isInteger(value) && Number(value) > 0 ? Number(value) : null;
-}

package/dist/sem-provider.d.ts

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

package/dist/sem-provider.js

@@ -1,252 +0,0 @@
-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 { gitUserLabel, sourceRangeForCommit, sourceRangeForRecentCommits, sourceRangeSince, stagedDiff, } from "./git.js";
-import { diagnostic } from "./ui.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, "stdin", ["stdin"]);
-    if (command.kind === "staged") {
-        const [diff, committer] = await Promise.all([stagedDiff(), gitUserLabel()]);
-        const committers = [committer];
-        if (!diff.text.trim())
-            return emptyChangeSet("staged", diff.stats, committers);
-        return semChangeSetFromPatch(diff.text, command.debugSem, "staged", committers);
-    }
-    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);
-}
-function emptyChangeSet(label, stats, committers) {
-    return {
-        id: sourceId(label),
-        label,
-        base: label,
-        target: label,
-        committers,
-        contextCwd: process.cwd(),
-        cleanup: async () => undefined,
-        changes: [],
-        summary: {
-            added: stats.additions,
-            deleted: stats.deletions,
-            modified: 0,
-            moved: 0,
-            renamed: 0,
-            fileCount: stats.filesChanged,
-            total: 0,
-        },
-    };
-}
-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 cannot resolve stdin as a git range.");
-}
-async function semChangeSetFromPatch(patch, debugSem, label = "stdin", committers) {
-    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(label),
-            label,
-            base: label,
-            target: label,
-            committers,
-            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)
-        diagnostic(`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())
-            diagnostic(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)
-        diagnostic(`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())
-                diagnostic(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)
-        diagnostic(`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,
-        committers: range.committers,
-        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

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-import type { SearchCommand, SearchRunJson } from "./types.ts";
-export declare function main(argv?: string[]): Promise<number>;
-export declare function runSearchCommand(command: SearchCommand, startedAt: number, ui?: {
-    intro(title: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    outro(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    note(message: string, title?: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    info(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    step(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    success(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    warn(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    error(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): void;
-    debug(message: string): void;
-    confirm(message: string): Promise<boolean>;
-    spinner(message: string, logOptions?: Readonly<{
-        force?: boolean;
-    }>): import("@clack/prompts").SpinnerResult;
-    progress(message: string, max: number, logOptions?: Readonly<{
-        force?: boolean;
-    }>): import("@clack/prompts").ProgressResult;
-    writeStdout(text: string): void;
-}): Promise<SearchRunJson>;