@stupify/cli 0.0.3 → 0.0.4

package/src/search-profile.ts

@@ -0,0 +1,89 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultChecks, searchChecks } from "./checks.ts";
+import type {
+  RepomixSearchConfig,
+  SearchProfile,
+  SearchProfilePattern,
+  StupifyCheck,
+} from "./types.ts";
+
+export async function loadSearchProfile(profilePath: string | null): Promise<SearchProfile | null> {
+  if (!profilePath) return null;
+  const fullPath = path.resolve(profilePath);
+  const value = JSON.parse(await readFile(fullPath, "utf8")) as SearchProfile;
+  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: readonly string[] | null,
+  profile: SearchProfile | null,
+): readonly StupifyCheck[] {
+  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: number, profile: SearchProfile | null): number {
+  return positiveInteger(profile?.maxCandidates) ?? defaultValue;
+}
+
+export function effectiveMaxSearchInputTokens(defaultValue: number, profile: SearchProfile | null): number {
+  return positiveInteger(profile?.maxSearchInputTokens) ?? defaultValue;
+}
+
+export function effectiveRepomixConfig(
+  defaultValue: RepomixSearchConfig,
+  profile: SearchProfile | null,
+): RepomixSearchConfig {
+  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: SearchProfile | null): readonly string[] {
+  if (!profile?.patterns) return [];
+  return Object.entries(profile.patterns)
+    .filter(([, pattern]) => pattern.enabled === true)
+    .map(([id]) => id);
+}
+
+function checksById(ids: readonly string[]): readonly StupifyCheck[] {
+  const byId = new Map<string, StupifyCheck>(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: StupifyCheck, override: SearchProfilePattern | undefined): StupifyCheck {
+  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: unknown): number | null {
+  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : null;
+}

package/src/sem-provider.ts

@@ -10,9 +10,10 @@ import {
   sourceRangeForCommit,
   sourceRangeForRecentCommits,
   sourceRangeSince,
+  stagedDiff,
 } from "./git.ts";
 import type {
-  AnalyzeCommand,
+  SearchCommand,
   SemChange,
   SemChangeSet,
   SemChangeSummary,
@@ -23,9 +24,14 @@ import { sourceId } from "./types.ts";
 const execFileAsync = promisify(execFile);
 
 export async function semChangeSetForCommand(
-  command: AnalyzeCommand,
+  command: SearchCommand,
 ): Promise<SemChangeSet> {
   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(
@@ -45,14 +51,35 @@ export async function semChangeSetForCommand(
   return withContextWorkspace(normalizeSemDiff(raw, range), command.debugSem);
 }
 
-async function semRangeForCommand(command: AnalyzeCommand): Promise<SourceRange> {
+function emptyChangeSet(label: string, stats: SourceRange["stats"]): SemChangeSet {
+  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: SearchCommand): Promise<SourceRange> {
   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.");
+  throw new Error("sem cannot resolve stdin as a git range.");
 }
 
-async function semChangeSetFromPatch(patch: string, debugSem: boolean): Promise<SemChangeSet> {
+async function semChangeSetFromPatch(patch: string, debugSem: boolean, label = "stdin"): Promise<SemChangeSet> {
   if (!patch.trim()) throw new Error("No diff received on stdin.");
   const raw = await cachedJson(
     "sem-diff",
@@ -66,10 +93,10 @@ async function semChangeSetFromPatch(patch: string, debugSem: boolean): Promise<
   );
   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(),