@stupify/cli 0.0.3 → 0.0.5

package/dist/search-profile.js

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

package/dist/sem-provider.js

@@ -6,12 +6,18 @@ 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 { sourceRangeForCommit, sourceRangeForRecentCommits, sourceRangeSince, stagedDiff, } 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 === "staged") {
+        const diff = await stagedDiff();
+        if (!diff.text.trim())
+            return emptyChangeSet("staged", diff.stats);
+        return semChangeSetFromPatch(diff.text, command.debugSem, "staged");
+    }
     if (command.kind === "commit") {
         const range = await sourceRangeForCommit(command.commit);
         const raw = await cachedSemDiff(["diff", "--commit", command.commit, "--format", "json"], range, command.debugSem);
@@ -21,6 +27,26 @@ export async function semChangeSetForCommand(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) {
+    return {
+        id: sourceId(label),
+        label,
+        base: label,
+        target: label,
+        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);
@@ -28,9 +54,9 @@ async function semRangeForCommand(command) {
         return sourceRangeForCommit(command.commit);
     if (command.kind === "commits")
         return sourceRangeForRecentCommits(command.count);
-    throw new Error("sem engine cannot resolve stdin as a git range.");
+    throw new Error("sem cannot resolve stdin as a git range.");
 }
-async function semChangeSetFromPatch(patch, debugSem) {
+async function semChangeSetFromPatch(patch, debugSem, label = "stdin") {
     if (!patch.trim())
         throw new Error("No diff received on stdin.");
     const raw = await cachedJson("sem-diff", fingerprint({
@@ -41,10 +67,10 @@ async function semChangeSetFromPatch(patch, debugSem) {
     }), () => runSemWithInput(["diff", "--patch", "--format", "json"], patch, debugSem));
     return {
         ...normalizeSemDiff(raw, {
-            id: sourceId("stdin"),
-            label: "stdin",
-            base: "stdin",
-            target: "stdin",
+            id: sourceId(label),
+            label,
+            base: label,
+            target: label,
             stats: { filesChanged: 0, additions: 0, deletions: 0 },
         }),
         contextCwd: process.cwd(),

package/dist/stupify.d.ts

@@ -1,2 +1,4 @@
 #!/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): Promise<SearchRunJson>;