@mrclrchtr/supi-code-intelligence 4.7.0 → 4.9.0

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/src/settings/settings-schema.ts

@@ -1,26 +1,19 @@
-// Declarative settings schema for SuPi extensions.
+// Fixed SuPi-config adapter for the canonical settings module interface.
 //
-// Replaces the imperative config-backed buildItems/persistChange contribution
-// with a declarative field descriptor model. The shared settings module owns
-// scope inheritance, source-state resolution, value rendering, persistence,
-// and Inherit/Reset-to-default actions.
+// Declarative field descriptors let the adapter own scope inheritance,
+// source-state resolution, value rendering, persistence, and Unset actions.
 //
 // Custom fields remain for nested or unusual config; they report the same
 // source state as declarative flat fields.
 
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 import {
   loadSupiConfigSectionForScope,
   removeSupiConfigKey,
   writeSupiConfig,
 } from "../config/config.ts";
-import {
-  isSettingsContributionCollector,
-  type SettingsScope,
-  type SettingsSection,
-  SUPI_SETTINGS_COLLECT_EVENT,
-} from "./settings-registry.ts";
+import type { SettingsApplyResult, SettingsModule, SettingsScope } from "./settings-registry.ts";
 
 // ── Types ──────────────────────────────────────────────────────────────────
 
@@ -52,10 +45,7 @@ export interface ConfigHelpers {
 // ── Field actions ─────────────────────────────────────────────────────────
 
 /** A user-initiated action on a settings row. */
-export type SettingsFieldAction =
-  | { kind: "set"; value: string }
-  | { kind: "inherit" }
-  | { kind: "resetToDefault" };
+export type SettingsAction = { kind: "set"; value: string } | { kind: "unset" };
 
 // ── Field descriptors ─────────────────────────────────────────────────────
 
@@ -153,15 +143,15 @@ export interface CustomField extends BaseField {
     ctx?: ExtensionContext,
   ) => Component;
   /**
-   * Persist handler called on set/inherit/resetToDefault actions.
+   * Persist handler called on set or unset actions.
    * Required for custom fields so they can write their nested config.
    */
   persist: (
     scope: SettingsScope,
     cwd: string,
-    action: SettingsFieldAction,
+    action: SettingsAction,
     helpers: ConfigHelpers,
-  ) => void;
+  ) => void | Promise<void>;
 }
 
 /** Union of all supported field kinds. */
@@ -176,8 +166,8 @@ export type SettingsField =
 
 // ── Contribution options ──────────────────────────────────────────────────
 
-/** Options for registerDeclarativeSettings. */
-export interface DeclarativeSettingsOptions {
+/** Options for the fixed SuPi-config settings adapter. */
+export interface ConfigSettingsOptions {
   /** Stable contribution identifier — e.g. "lsp", "claude-md". */
   id: string;
   /** Human-readable label shown in the UI. */
@@ -194,7 +184,7 @@ export interface DeclarativeSettingsOptions {
   homeDir?: string;
 }
 
-// ── Scoped section interface ─────────────────────────────────────────────
+// ── Source-aware row interface ───────────────────────────────────────────
 
 /** Resolved value for one field in one scope. */
 export interface ScopedFieldValue {
@@ -305,14 +295,14 @@ function createConfigHelpers(
   };
 }
 
-// ── Scoped section factory ────────────────────────────────────────────────
+// ── Fixed config adapter ─────────────────────────────────────────────────
 
 interface NotifyAfterPersistInput {
-  options: DeclarativeSettingsOptions;
+  options: ConfigSettingsOptions;
   field: SettingsField;
   scope: SettingsScope;
   cwd: string;
-  action: SettingsFieldAction;
+  action: SettingsAction;
   storedValue: unknown;
   ctx?: ExtensionContext;
 }
@@ -354,86 +344,86 @@ function notifyAfterPersist(input: NotifyAfterPersistInput): void {
   options.afterPersist(change);
 }
 
-function toDeclarativeSection(options: DeclarativeSettingsOptions): SettingsSection {
+function resolveConfigRows(
+  options: ConfigSettingsOptions,
+  scope: SettingsScope,
+  cwd: string,
+  ctx?: ExtensionContext,
+): ScopedFieldValue[] {
   const defaults = options.defaults as Record<string, unknown>;
+  const projectRaw = loadSupiConfigSectionForScope(options.section, cwd, {
+    scope: "project",
+    homeDir: options.homeDir,
+  });
+  const globalRaw = loadSupiConfigSectionForScope(options.section, cwd, {
+    scope: "global",
+    homeDir: options.homeDir,
+  });
+
+  return options.fields.map((field) => {
+    if (field.kind === "custom") {
+      const resolved = field.resolve(scope, cwd, ctx);
+      return {
+        field,
+        displayValue: resolved.displayValue
+          ? sourceBadge(resolved.displayValue, resolved.source)
+          : "",
+        editValue: resolved.editValue ?? resolved.displayValue,
+        source: resolved.source,
+        inheritanceSource: resolved.inheritanceSource,
+      };
+    }
+
+    const { value, source } = resolveValue(field.key, defaults, projectRaw, globalRaw, scope);
+    const displayValue = formatValue(value, field);
+    const inheritanceSource =
+      scope === "project" && source === "project"
+        ? globalRaw && field.key in globalRaw
+          ? "global"
+          : "default"
+        : undefined;
+
+    return {
+      field,
+      displayValue: sourceBadge(displayValue, source),
+      editValue: formatEditValue(value, field),
+      source,
+      inheritanceSource,
+    };
+  });
+}
+
+async function applyConfigAction(
+  options: ConfigSettingsOptions,
+  request: Parameters<SettingsModule["apply"]>[0],
+): Promise<SettingsApplyResult> {
+  const { scope, cwd, fieldKey, action, ctx } = request;
+  const field = options.fields.find((candidate) => candidate.key === fieldKey);
+  if (!field) return {};
+
+  const helpers = createConfigHelpers(options.section, scope, cwd, options.homeDir);
+  let storedValue: unknown;
+  if (field.kind === "custom") {
+    await field.persist(scope, cwd, action, helpers);
+    storedValue = action.kind === "set" ? action.value : undefined;
+  } else if (action.kind === "set") {
+    storedValue = parseTypedValue(action.value, field);
+    helpers.set(field.key, storedValue);
+  } else {
+    helpers.unset(field.key);
+  }
+  notifyAfterPersist({ options, field, scope, cwd, action, storedValue, ctx });
+  return {};
+}
+
+/** Adapt one fixed SuPi config section to the canonical settings interface. */
+export function defineConfigSettings(options: ConfigSettingsOptions): SettingsModule {
   return {
     id: options.id,
     label: options.label,
-    loadValues: (scope, cwd, ctx) => {
-      // Load raw section data for both scopes (no defaults)
-      const projectRaw = loadSupiConfigSectionForScope(options.section, cwd, {
-        scope: "project",
-        homeDir: options.homeDir,
-      });
-      const globalRaw = loadSupiConfigSectionForScope(options.section, cwd, {
-        scope: "global",
-        homeDir: options.homeDir,
-      });
-
-      // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: natural discriminator on field kind and source
-      return options.fields.map((field) => {
-        if (field.kind === "custom") {
-          const resolved = field.resolve(scope, cwd, ctx);
-          return {
-            field,
-            displayValue: resolved.displayValue
-              ? sourceBadge(resolved.displayValue, resolved.source)
-              : "",
-            editValue: resolved.editValue ?? resolved.displayValue,
-            source: resolved.source,
-            inheritanceSource: resolved.inheritanceSource,
-          };
-        }
-
-        const { value, source } = resolveValue(field.key, defaults, projectRaw, globalRaw, scope);
-        const displayValue = formatValue(value, field);
-
-        // Compute inheritanceSource for project-scope overrides
-        let inheritanceSource: "global" | "default" | undefined;
-        if (scope === "project" && source === "project") {
-          inheritanceSource = globalRaw && field.key in globalRaw ? "global" : "default";
-        }
-
-        return {
-          field,
-          displayValue: sourceBadge(displayValue, source),
-          editValue: formatEditValue(value, field),
-          source,
-          inheritanceSource,
-        };
-      });
-    },
-    // biome-ignore lint/complexity/useMaxParams: SettingsSection action handlers receive scope, cwd, field, action, and optional context
-    handleAction: (scope, cwd, fieldKey, action, ctx) => {
-      const field = options.fields.find((f) => f.key === fieldKey);
-      if (!field) return;
-
-      const section = options.section;
-      const helpers = createConfigHelpers(section, scope, cwd, options.homeDir);
-      let storedValue: unknown;
-
-      if (field.kind === "custom") {
-        field.persist(scope, cwd, action, helpers);
-        storedValue = action.kind === "set" ? action.value : undefined;
-        notifyAfterPersist({ options, field, scope, cwd, action, storedValue, ctx });
-        return;
-      }
-
-      switch (action.kind) {
-        case "set": {
-          storedValue = parseTypedValue(action.value, field);
-          helpers.set(field.key, storedValue);
-          break;
-        }
-        case "inherit":
-        case "resetToDefault": {
-          helpers.unset(field.key);
-          break;
-        }
-      }
-
-      notifyAfterPersist({ options, field, scope, cwd, action, storedValue, ctx });
-    },
+    read: ({ scope, cwd, ctx }) =>
+      Promise.resolve({ rows: resolveConfigRows(options, scope, cwd, ctx) }),
+    apply: (request) => applyConfigAction(options, request),
   };
 }
 
@@ -461,27 +451,3 @@ export function parseTypedValue(value: string, field: SettingsField): unknown {
       return value;
   }
 }
-
-// ── Registration ──────────────────────────────────────────────────────────
-
-/**
- * Register a declarative settings contribution for `/supi-settings`.
- *
- * Contributions are collected through PI's process-local event bus. Call this
- * during the extension factory function, not in async session handlers.
- */
-export function registerDeclarativeSettings(
-  pi: ExtensionAPI,
-  options: DeclarativeSettingsOptions,
-): void {
-  const section = toDeclarativeSection(options);
-  const dispose = pi.events.on(SUPI_SETTINGS_COLLECT_EVENT, (collector) => {
-    if (isSettingsContributionCollector(collector)) {
-      collector.add(section);
-    }
-  });
-
-  pi.on("session_shutdown", () => {
-    dispose();
-  });
-}

package/node_modules/@mrclrchtr/supi-tree-sitter/node_modules/@mrclrchtr/supi-core/src/settings.ts

@@ -1,33 +1,36 @@
-// supi-core settings domain — event-backed declarative settings contributions and command wiring.
-
-export { registerSettingsCommand } from "./settings/settings-command.ts";
+// supi-core settings domain — settings modules and fixed-config adapters.
 export type {
+  SettingsActionRequest,
+  SettingsApplyResult,
   SettingsCollectionDiagnostic,
   SettingsCollectionResult,
+  SettingsContext,
   SettingsContributionCollector,
+  SettingsModule,
   SettingsScope,
-  SettingsSection,
+  SettingsSnapshot,
 } from "./settings/settings-registry.ts";
 export {
   createSettingsContributionCollector,
   isSettingsContributionCollector,
+  registerSettings,
   SUPI_SETTINGS_COLLECT_EVENT,
 } from "./settings/settings-registry.ts";
 export type {
   BoolField,
   ConfigHelpers,
+  ConfigSettingsOptions,
   CustomField,
-  DeclarativeSettingsOptions,
   EnumField,
   ModelPickerField,
   ModelPickerStaticOption,
   NumberField,
   ScopedFieldValue,
+  SettingsAction,
   SettingsField,
-  SettingsFieldAction,
   SettingsPersistedChange,
   StringField,
   StringListField,
   ValueSource,
 } from "./settings/settings-schema.ts";
-export { registerDeclarativeSettings } from "./settings/settings-schema.ts";
+export { defineConfigSettings } from "./settings/settings-schema.ts";

package/node_modules/@mrclrchtr/supi-tree-sitter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-tree-sitter",
-  "version": "4.7.0",
+  "version": "4.9.0",
   "description": "Structural AST analysis for SuPi code intelligence",
   "license": "MIT",
   "repository": {
@@ -34,8 +34,8 @@
   ],
   "dependencies": {
     "web-tree-sitter": "^0.26.8",
-    "@mrclrchtr/supi-code-runtime": "4.7.0",
-    "@mrclrchtr/supi-core": "4.7.0"
+    "@mrclrchtr/supi-code-runtime": "4.9.0",
+    "@mrclrchtr/supi-core": "4.9.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-code-intelligence",
-  "version": "4.7.0",
+  "version": "4.9.0",
   "description": "LSP and AST navigation, search, diagnostics, and refactoring",
   "license": "MIT",
   "repository": {
@@ -35,10 +35,10 @@
   ],
   "dependencies": {
     "yaml": "^2.9.0",
-    "@mrclrchtr/supi-code-runtime": "4.7.0",
-    "@mrclrchtr/supi-lsp": "4.7.0",
-    "@mrclrchtr/supi-tree-sitter": "4.7.0",
-    "@mrclrchtr/supi-core": "4.7.0"
+    "@mrclrchtr/supi-code-runtime": "4.9.0",
+    "@mrclrchtr/supi-core": "4.9.0",
+    "@mrclrchtr/supi-tree-sitter": "4.9.0",
+    "@mrclrchtr/supi-lsp": "4.9.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-code-runtime",

package/src/analysis/search/ast-scan-timing.ts

@@ -0,0 +1,59 @@
+import { startDebugTimer } from "@mrclrchtr/supi-core/debug";
+import type { StructuralSearchOperation } from "@mrclrchtr/supi-tree-sitter/api";
+import type { StructuredFileAnalysis, StructuredPatternParams } from "./pattern-analysis.ts";
+
+interface ScanContext {
+  readonly cwd: string;
+  readonly params: StructuredPatternParams;
+}
+
+interface EnumerationMetrics {
+  readonly eligibleFileCount: number | null;
+}
+
+interface AstScanTimingInput {
+  readonly context: ScanContext;
+  readonly operation: StructuralSearchOperation;
+  readonly roots: readonly string[];
+  readonly enumeration: EnumerationMetrics;
+  readonly analysis: StructuredFileAnalysis;
+  readonly complete: boolean;
+}
+
+/** One-shot timer that records aggregate AST scan phases. */
+export interface AstScanTimer {
+  enumerationCompleted(): void;
+  record(input: AstScanTimingInput): void;
+}
+
+/** Start one AST scan timer without adding paths to debug-event data. */
+export function startAstScanTimer(): AstScanTimer {
+  const timer = startDebugTimer();
+  return {
+    enumerationCompleted() {
+      timer.mark("enumeration");
+    },
+    record(input) {
+      timer.finish(
+        () => ({
+          source: "code-intelligence",
+          level: "debug",
+          category: "ast-scan.timing",
+          message: `AST ${input.context.params.kind} scan analyzed ${input.analysis.analyzedFileCount} files`,
+          cwd: input.context.cwd,
+          data: {
+            kind: input.context.params.kind,
+            operation: input.operation,
+            rootCount: input.roots.length,
+            eligibleFileCount: input.enumeration.eligibleFileCount,
+            analyzedFileCount: input.analysis.analyzedFileCount,
+            matchCount: input.analysis.matches.length,
+            failureCount: input.analysis.failures.length,
+            complete: input.complete,
+          },
+        }),
+        "analysis",
+      );
+    },
+  };
+}

package/src/analysis/search/pattern-analysis.ts

@@ -0,0 +1,230 @@
+import type {
+  CodeResult,
+  OutlineData,
+  StructuralProvider as StructuralSubstrate,
+} from "@mrclrchtr/supi-code-runtime/api";
+import type { CodeFindAstKind } from "../../tool/find/ast-kinds.ts";
+import type { AstScanLimitation } from "./ast-scan.ts";
+import { callableExpressionForMatching } from "./call-name.ts";
+import { settleByDeadline } from "./deadline.ts";
+import { relativeDisplayPath } from "./paths.ts";
+
+export interface StructuredPatternParams {
+  readonly pattern: string;
+  readonly kind: CodeFindAstKind;
+}
+
+export interface StructuredMatch {
+  readonly file: string;
+  readonly name: string;
+  readonly kind: string;
+  readonly line: number;
+}
+
+export type StructuredFailureKind = Exclude<CodeResult<never>, { kind: "success" }>["kind"];
+
+export interface StructuredFailure {
+  readonly file: string;
+  readonly kind: StructuredFailureKind;
+  readonly reason: string;
+}
+
+export type StructuredScanLimitation = AstScanLimitation | ProviderScanLimitation;
+
+export interface ProviderScanLimitation {
+  readonly reason: "provider-failure";
+  readonly pathCount: number;
+  readonly examples: readonly string[];
+}
+
+export interface StructuredFileAnalysis {
+  readonly matches: StructuredMatch[];
+  readonly failures: StructuredFailure[];
+  readonly limitations: StructuredScanLimitation[];
+  readonly analyzedFileCount: number;
+}
+
+interface AnalyzeStructuredFilesOptions {
+  readonly files: readonly string[];
+  readonly displayBase: string;
+  readonly params: StructuredPatternParams;
+  readonly structural: StructuralSubstrate;
+  readonly deadline: number;
+  readonly now: () => number;
+  readonly signal?: AbortSignal;
+  readonly initialLimitations: readonly AstScanLimitation[];
+}
+
+/** Analyze enumerated files through the operation-specific structural provider method. */
+export async function analyzeStructuredFiles(
+  options: AnalyzeStructuredFilesOptions,
+): Promise<StructuredFileAnalysis> {
+  const matches: StructuredMatch[] = [];
+  const failures: StructuredFailure[] = [];
+  const limitations: StructuredScanLimitation[] = [...options.initialLimitations];
+  const matcher = createStructuredMatcher(options.params.pattern);
+  let analyzedFileCount = 0;
+
+  for (const [index, absoluteFile] of options.files.entries()) {
+    options.signal?.throwIfAborted();
+    if (options.now() > options.deadline) {
+      addAnalysisTimeout(limitations, options.files.slice(index), options.displayBase);
+      break;
+    }
+    const relativeFile = relativeDisplayPath(options.displayBase, absoluteFile);
+    const fileMatches: StructuredMatch[] = [];
+    const fileFailures: StructuredFailure[] = [];
+    const outcome = await settleByDeadline(
+      async () => {
+        try {
+          await collectMatchesForFile(
+            fileMatches,
+            fileFailures,
+            options.structural,
+            relativeFile,
+            options.params.kind,
+            matcher,
+          );
+        } catch (error) {
+          fileFailures.push({
+            file: relativeFile,
+            kind: "runtime-error",
+            reason: errorMessage(error),
+          });
+        }
+      },
+      { deadline: options.deadline, now: options.now, signal: options.signal },
+    );
+    if (outcome.kind === "timeout") {
+      addAnalysisTimeout(limitations, options.files.slice(index), options.displayBase);
+      break;
+    }
+    options.signal?.throwIfAborted();
+    matches.push(...fileMatches);
+    failures.push(...fileFailures);
+    if (fileFailures.length === 0) analyzedFileCount += 1;
+  }
+
+  if (failures.length > 0) {
+    limitations.push({
+      reason: "provider-failure",
+      pathCount: failures.length,
+      examples: failures.slice(0, 5).map((failure) => failure.file),
+    });
+  }
+  return { matches, failures, limitations, analyzedFileCount };
+}
+
+function addAnalysisTimeout(
+  limitations: StructuredScanLimitation[],
+  remainingFiles: readonly string[],
+  cwd: string,
+): void {
+  if (limitations.some((limitation) => limitation.reason === "timeout")) return;
+  limitations.push({
+    reason: "timeout",
+    pathCount: remainingFiles.length,
+    examples: remainingFiles.slice(0, 5).map((file) => relativeDisplayPath(cwd, file)),
+  });
+}
+
+// biome-ignore lint/complexity/useMaxParams: helper takes explicit collection inputs to avoid intermediate objects in the hot path
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: kind-specific tree-sitter matching is clearest as one helper
+async function collectMatchesForFile(
+  matches: StructuredMatch[],
+  failures: StructuredFailure[],
+  structural: StructuralSubstrate,
+  relFile: string,
+  kind: CodeFindAstKind,
+  matcher: (value: string) => boolean,
+): Promise<void> {
+  const recordFailure = (kind: StructuredFailureKind, reason: string) => {
+    failures.push({ file: relFile, kind, reason });
+  };
+
+  if (kind === "definition") {
+    const outline = await structural.outline(relFile);
+    if (!handleStructuralResult(outline, recordFailure)) return;
+    for (const item of flattenOutlineItems(outline.data)) {
+      if (!matcher(item.name)) continue;
+      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
+    }
+    return;
+  }
+
+  if (kind === "export") {
+    const exportsResult = await structural.exports(relFile);
+    if (!handleStructuralResult(exportsResult, recordFailure)) return;
+    for (const item of exportsResult.data) {
+      if (!matcher(item.name)) continue;
+      matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
+    }
+    return;
+  }
+
+  if (kind === "import") {
+    const importsResult = await structural.imports(relFile);
+    if (!handleStructuralResult(importsResult, recordFailure)) return;
+    for (const item of importsResult.data) {
+      if (!matcher(item.moduleSpecifier)) continue;
+      matches.push({
+        file: relFile,
+        name: item.moduleSpecifier,
+        kind: "import",
+        line: item.startLine,
+      });
+    }
+    return;
+  }
+
+  if (kind === "call") {
+    const callResult = await structural.callSites(relFile);
+    if (!handleStructuralResult(callResult, recordFailure)) return;
+    for (const call of callResult.data) {
+      if (!matcher(callableExpressionForMatching(call.name))) continue;
+      matches.push({ file: relFile, name: call.name, kind: "call", line: call.startLine });
+    }
+    return;
+  }
+
+  const outline = await structural.outline(relFile);
+  if (!handleStructuralResult(outline, recordFailure)) return;
+  for (const item of flattenOutlineItems(outline.data)) {
+    if (kind === "type" && !TYPE_KIND.test(item.kind.toLowerCase())) continue;
+    if (kind === "interface" && item.kind.toLowerCase() !== "interface") continue;
+    if (kind === "class" && item.kind.toLowerCase() !== "class") continue;
+    if (kind === "method" && item.kind.toLowerCase() !== "method") continue;
+    if (kind === "enum" && item.kind.toLowerCase() !== "enum") continue;
+    if (!matcher(item.name)) continue;
+    matches.push({ file: relFile, name: item.name, kind: item.kind, line: item.startLine });
+  }
+}
+
+/** Flatten provider outlines so nested class/interface/enum declarations remain searchable. */
+function flattenOutlineItems(items: readonly OutlineData[]): OutlineData[] {
+  return items.flatMap((item) => [item, ...flattenOutlineItems(item.children ?? [])]);
+}
+
+function handleStructuralResult<T>(
+  result: CodeResult<T>,
+  recordFailure: (kind: StructuredFailureKind, reason: string) => void,
+): result is { kind: "success"; data: T } {
+  if (result.kind === "success") return true;
+  recordFailure(result.kind, result.message);
+  return false;
+}
+
+function createStructuredMatcher(pattern: string): (value: string) => boolean {
+  const ignoreCase = !/[A-Z]/.test(pattern);
+  const needle = ignoreCase ? pattern.toLowerCase() : pattern;
+  return (value: string) => {
+    const haystack = ignoreCase ? value.toLowerCase() : value;
+    return haystack.includes(needle);
+  };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Structural provider failed.";
+}
+
+const TYPE_KIND = /^(?:class|interface|type|enum|struct|union|record|object|concept)$/;