@mrclrchtr/supi-code-intelligence 2.1.0 → 2.2.0

package/src/app/app.ts

@@ -77,8 +77,9 @@ export function createCodeIntelligenceApp(pi: ExtensionAPI): CodeIntelligenceApp
   pi.on("session_start", (_event, ctx) => {
     const session = manager.getOrCreateSession(ctx.cwd);
 
-    // Check if the branch already contains an overview
+    // Check if the branch already contains an overview and restore branch-local instruction state.
     const branch = ctx.sessionManager.getBranch();
+    session.reconstructInstructionState(branch);
     for (const entry of branch) {
       if (
         entry.type === "custom_message" &&
@@ -90,6 +91,10 @@ export function createCodeIntelligenceApp(pi: ExtensionAPI): CodeIntelligenceApp
     }
   });
 
+  pi.on("session_compact", (_event, ctx) => {
+    manager.getSession(ctx.cwd)?.resetSurfacedInstructionDirs();
+  });
+
   pi.on("session_shutdown", () => {
     // Clear per-session stores before releasing sessions
     for (const session of manager.allSessions()) {

package/src/config.ts

@@ -0,0 +1,42 @@
+// Code Intelligence configuration and settings registration.
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { loadSupiConfig } from "@mrclrchtr/supi-core/config";
+import { registerDeclarativeSettings } from "@mrclrchtr/supi-core/settings";
+
+const CODE_INTELLIGENCE_SECTION = "code-intelligence";
+
+/** User-facing configuration for the code-intelligence extension. */
+export interface CodeIntelligenceConfig extends Record<string, unknown> {
+  /** Ordered directory-local instruction file names to surface during directory orientation. */
+  instructionFileNames: string[];
+}
+
+/** Default code-intelligence configuration. */
+export const CODE_INTELLIGENCE_DEFAULTS: CodeIntelligenceConfig = {
+  instructionFileNames: ["CLAUDE.md", "AGENTS.md"],
+};
+
+/** Load merged code-intelligence configuration for a workspace. */
+export function loadCodeIntelligenceConfig(cwd: string, homeDir?: string): CodeIntelligenceConfig {
+  return loadSupiConfig(CODE_INTELLIGENCE_SECTION, cwd, CODE_INTELLIGENCE_DEFAULTS, { homeDir });
+}
+
+/** Register code-intelligence settings with the shared SuPi settings registry. */
+export function registerCodeIntelligenceSettings(pi: ExtensionAPI, homeDir?: string): void {
+  registerDeclarativeSettings(pi, {
+    id: CODE_INTELLIGENCE_SECTION,
+    label: "Code Intelligence",
+    section: CODE_INTELLIGENCE_SECTION,
+    defaults: CODE_INTELLIGENCE_DEFAULTS,
+    fields: [
+      {
+        kind: "stringList" as const,
+        key: "instructionFileNames",
+        label: "Instruction File Names",
+        description: "Directory-local instruction file names shown by directory orientation",
+      },
+    ],
+    ...(homeDir ? { homeDir } : {}),
+  });
+}

package/src/extension.ts

@@ -8,6 +8,7 @@ import {
   gatherCoverageEvalInput,
 } from "./analysis/coverage/coverage-warnings.ts";
 import { createCodeIntelligenceApp } from "./app/app.ts";
+import { registerCodeIntelligenceSettings } from "./config.ts";
 import type { WorkspaceCodeIntelligenceSession } from "./session/session.ts";
 import { registerDiagnosticInjectionHandlers } from "./substrate/lsp/diagnostic-injection.ts";
 import { registerLspSessionLifecycle } from "./substrate/lsp/lifecycle.ts";
@@ -38,6 +39,7 @@ export default function codeIntelligenceExtension(
   const tsState = createTsAdapterState();
 
   // ── Substrate wiring ──────────────────────────────────────────────
+  registerCodeIntelligenceSettings(pi);
   registerLspSettings(pi);
   registerLspSessionLifecycle(pi, lspState);
   registerLspAwareToolOverrides(pi, lspState);
@@ -64,6 +66,12 @@ export default function codeIntelligenceExtension(
   registerCiStatusCommand(pi);
   registerLspFooterContribution(lspState);
 
+  // ── Native context path capture for instruction-file dedup ─────────
+  pi.on("before_agent_start", (event, ctx) => {
+    const session = app.getSession(ctx.cwd) ?? app.createSession(ctx.cwd);
+    session.captureNativeInstructionPaths(event.systemPromptOptions.contextFiles ?? []);
+  });
+
   // ── Coverage warning emission ─────────────────────────────────────
   pi.on(
     "before_agent_start",

package/src/session/session.ts

@@ -15,6 +15,8 @@
  * @mrclrchtr/supi-code-intelligence — internal, not exported via api.ts
  */
 
+import * as path from "node:path";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import {
   getDefaultWorkspaceRuntime,
   type SemanticProvider,
@@ -104,6 +106,12 @@ export class WorkspaceCodeIntelligenceSession {
    */
   readonly coverageWarningState = new CoverageWarningState();
 
+  /** Absolute instruction files already loaded by PI's native context-file mechanism. */
+  readonly nativeInstructionPaths = new Set<string>();
+
+  /** Absolute directories whose instruction files were already surfaced by code_orientation. */
+  readonly surfacedInstructionDirs = new Set<string>();
+
   /**
    * Optional LSP controller reference — attached by LSP lifecycle module
    * for coverage evaluation and server management.
@@ -142,6 +150,38 @@ export class WorkspaceCodeIntelligenceSession {
     });
   }
 
+  // ── Instruction-file state ───────────────────────────────────────
+
+  /** Remember instruction/context file paths already loaded by PI natively. */
+  captureNativeInstructionPaths(files: Array<{ path: string }>): void {
+    for (const file of files) {
+      this.nativeInstructionPaths.add(path.resolve(this.cwd, file.path));
+    }
+  }
+
+  /** Mark directory-local instruction files as surfaced after a successful orientation render. */
+  markInstructionDirsSurfaced(directories: string[]): void {
+    for (const directory of directories) {
+      this.surfacedInstructionDirs.add(path.resolve(this.cwd, directory));
+    }
+  }
+
+  /** Clear instruction-file dedup state after compaction. */
+  resetSurfacedInstructionDirs(): void {
+    this.surfacedInstructionDirs.clear();
+  }
+
+  /** Reconstruct surfaced instruction directories from branch tool-result details after compaction. */
+  reconstructInstructionState(branch: SessionEntry[]): void {
+    this.surfacedInstructionDirs.clear();
+    const entries = entriesAfterLatestCompaction(branch);
+    for (const entry of entries) {
+      for (const directory of extractInstructionDirectories(entry)) {
+        this.surfacedInstructionDirs.add(path.resolve(this.cwd, directory));
+      }
+    }
+  }
+
   // ── Provider access ───────────────────────────────────────────────
 
   /**
@@ -290,7 +330,34 @@ export class WorkspaceCodeIntelligenceSession {
   clearStores(): void {
     this.#refactorPlans.clear();
     this.#workflowTargets.clear();
+    this.surfacedInstructionDirs.clear();
+    this.nativeInstructionPaths.clear();
+  }
+}
+
+function entriesAfterLatestCompaction(branch: SessionEntry[]): SessionEntry[] {
+  let start = 0;
+  for (let i = 0; i < branch.length; i++) {
+    if (branch[i]?.type === "compaction") start = i + 1;
   }
+  return branch.slice(start);
+}
+
+function extractInstructionDirectories(entry: SessionEntry): string[] {
+  if (entry.type !== "message" || entry.message.role !== "toolResult") return [];
+  if (entry.message.toolName !== "code_orientation") return [];
+
+  const details = entry.message.details as
+    | { type?: string; data?: { instructions?: { files?: Array<{ directory?: unknown }> } } }
+    | undefined;
+  if (details?.type !== "context") return [];
+
+  const files = details.data?.instructions?.files;
+  if (!Array.isArray(files)) return [];
+
+  return files
+    .map((file) => file.directory)
+    .filter((directory): directory is string => typeof directory === "string");
 }
 
 // ── Standalone target-id expansion helper ─────────────────────────────

package/src/substrate/lsp/diagnostic-injection.ts

@@ -12,9 +12,6 @@ import {
 import type { LspAdapterState } from "./state.ts";
 import { diagnosticMessageString } from "./utils.ts";
 
-// LSP_TOOL_NAMES removed — lsp_* tools are no longer registered (TNDM-A9AQF4)
-const LSP_TOOL_NAMES: readonly string[] = [];
-
 export function registerDiagnosticInjectionHandlers(
   pi: ExtensionAPI,
   state: LspAdapterState,
@@ -22,21 +19,9 @@ export function registerDiagnosticInjectionHandlers(
   pi.on("before_agent_start", async (_event, _ctx: ExtensionContext) => {
     const manager = state.controller?.manager;
     if (!manager || !state.lspActive) {
-      const activeTools = pi.getActiveTools();
-      const nextTools = activeTools.filter(
-        (t: string) => !LSP_TOOL_NAMES.includes(t as (typeof LSP_TOOL_NAMES)[number]),
-      );
-      if (nextTools.length !== activeTools.length) {
-        pi.setActiveTools(nextTools);
-      }
       return;
     }
 
-    const missing = LSP_TOOL_NAMES.filter((name) => !pi.getActiveTools().includes(name));
-    if (missing.length > 0) {
-      pi.setActiveTools([...pi.getActiveTools(), ...missing]);
-    }
-
     // Sentinel refresh: detect lockfile/tsconfig/d.ts changes from outside write/edit
     applySentinelChanges(state, manager);
 

package/src/substrate/lsp/settings.ts

@@ -4,26 +4,21 @@
 // are deprecated and ignored. Per-language disable via
 // `lsp.servers.<language>.enabled: false` is the only supported opt-out.
 //
-// This settings section provides:
-// - severity control
-// - excluded patterns
-// - a "Disabled Servers" submenu that writes per-language disable config
+// Uses the declarative settings schema with:
+// - severity: number with labeled values
+// - exclude: stringList
+// - disabled_servers: custom submenu that writes per-language disable config
 
-import {
-  CONFIG_DIR_NAME,
-  type ExtensionAPI,
-  getSettingsListTheme,
-} from "@earendil-works/pi-coding-agent";
-import type { SettingItem } from "@earendil-works/pi-tui";
+import { type ExtensionAPI, getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import type { Component, SettingItem } from "@earendil-works/pi-tui";
 import { Container, Key, matchesKey, SettingsList, Text } from "@earendil-works/pi-tui";
 
-type SettingsScope = "project" | "global";
-
+import { loadSupiConfigSectionForScope, writeSupiConfig } from "@mrclrchtr/supi-core/config";
 import {
-  loadSupiConfigForScope,
-  registerConfigSettings,
-  writeSupiConfig,
-} from "@mrclrchtr/supi-core/config";
+  registerDeclarativeSettings,
+  type SettingsScope,
+  type ValueSource,
+} from "@mrclrchtr/supi-core/settings";
 import { type LspSettings, loadConfig } from "@mrclrchtr/supi-lsp/api";
 
 const LSP_DEFAULTS: LspSettings = {
@@ -33,21 +28,6 @@ const LSP_DEFAULTS: LspSettings = {
   exclude: [],
 };
 
-function severityLabel(severity: number): string {
-  switch (severity) {
-    case 1:
-      return "errors";
-    case 2:
-      return "warnings";
-    case 3:
-      return "info";
-    case 4:
-      return "hints";
-    default:
-      return "errors";
-  }
-}
-
 /** Discover configured servers from the defaults + effective LSP config. */
 function getConfiguredServers(cwd: string): string[] {
   try {
@@ -63,12 +43,10 @@ function getConfiguredServers(cwd: string): string[] {
  * configured disabled servers from the persisted config.
  */
 function getDisabledServersFromConfig(scope: SettingsScope, cwd: string): Set<string> {
-  const section = loadSupiConfigForScope(
-    "lsp",
-    cwd,
-    { servers: {} as Record<string, { enabled?: boolean }> },
-    { scope },
-  );
+  const section = loadSupiConfigSectionForScope("lsp", cwd, {
+    scope,
+  });
+  if (!section) return new Set();
   const servers = section.servers as Record<string, { enabled?: boolean }> | undefined;
   const disabled = new Set<string>();
   if (servers) {
@@ -79,75 +57,11 @@ function getDisabledServersFromConfig(scope: SettingsScope, cwd: string): Set<st
   return disabled;
 }
 
-export function registerLspSettings(pi: ExtensionAPI): void {
-  registerConfigSettings(pi, {
-    id: "lsp",
-    label: "LSP",
-    section: "lsp",
-    defaults: LSP_DEFAULTS,
-    buildItems: (settings, scope, cwd) => buildLspSettingItems(settings, scope, cwd),
-    // biome-ignore lint/complexity/useMaxParams: registerConfigSettings callback signature
-    persistChange: (_scope, _cwd, settingId, value, helpers) => {
-      switch (settingId) {
-        case "severity": {
-          const num = Number.parseInt(value.split(" ")[0] ?? "1", 10);
-          helpers.set("severity", Number.isNaN(num) ? 1 : num);
-          break;
-        }
-        case "exclude": {
-          const patterns = value
-            .split(",")
-            .map((s) => s.trim())
-            .filter(Boolean);
-          if (patterns.length > 0) helpers.set("exclude", patterns);
-          else helpers.unset("exclude");
-          break;
-        }
-      }
-    },
-  });
-}
-
-function buildLspSettingItems(
-  settings: LspSettings,
-  scope: "project" | "global",
-  cwd: string,
-): SettingItem[] {
-  return [
-    {
-      id: "severity",
-      label: "Inline Severity",
-      description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
-      currentValue: `${settings.severity} (${severityLabel(settings.severity)})`,
-      values: ["1 (errors)", "2 (warnings)", "3 (info)", "4 (hints)"],
-    },
-    {
-      id: "disabled_servers",
-      label: "Disabled Servers",
-      description: "Press Enter to choose which language servers to disable",
-      currentValue: renderDisabledServersLabel(scope, cwd),
-      submenu: (_currentValue, done) => createDisabledServersSubmenu(scope, cwd, done),
-    },
-    {
-      id: "exclude",
-      label: "Exclude Patterns",
-      description: "Gitignore patterns to suppress LSP diagnostics",
-      currentValue: settings.exclude.length > 0 ? settings.exclude.join(", ") : "none",
-      submenu: (_currentValue, done) => createExcludeSubmenu(scope, cwd, settings, done),
-    },
-  ];
-}
-
-function renderDisabledServersLabel(scope: SettingsScope, cwd: string): string {
-  const disabled = getDisabledServersFromConfig(scope, cwd);
-  return disabled.size > 0 ? [...disabled].sort().join(", ") : "none disabled";
-}
-
 function createDisabledServersSubmenu(
   scope: SettingsScope,
   cwd: string,
-  done: (value?: string) => void,
-) {
+  done: (selectedValue?: string) => void,
+): Component {
   const allServers = getConfiguredServers(cwd);
   const disabledServers = getDisabledServersFromConfig(scope, cwd);
 
@@ -160,14 +74,7 @@ function createDisabledServersSubmenu(
 
   let dirty = false;
   const container = new Container();
-  const header = new Text("Disabled Servers — per-language opt-out", 0, 0);
-  container.addChild(header);
-  const footer = new Text(
-    "Marking a server as disabled writes lsp.servers.<lang>.enabled: false for this scope",
-    0,
-    0,
-  );
-  container.addChild(footer);
+  container.addChild(new Text("  Disabled Servers — per-language opt-out", 1, 0));
 
   const settingsList = new SettingsList(
     items,
@@ -184,26 +91,22 @@ function createDisabledServersSubmenu(
     { enableSearch: true },
   );
   container.addChild(settingsList);
+  container.addChild(new Text("  esc save and close", 1, 0));
 
   return {
     render: (width: number) => container.render(width),
     invalidate: () => container.invalidate(),
-    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: single event handler dispatching keyboard shortcuts for the Disabled Servers submenu
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: single event handler for the submenu
     handleInput: (data: string) => {
       if (matchesKey(data, Key.escape)) {
         if (!dirty) {
           done();
-          return true;
+          return;
         }
         // Write per-language enabled/disabled into lsp.servers
-        const currentSection = loadSupiConfigForScope(
-          "lsp",
-          cwd,
-          { servers: {} as Record<string, { enabled?: boolean }> },
-          { scope },
-        );
+        const currentSection = loadSupiConfigSectionForScope("lsp", cwd, { scope });
         const servers =
-          (currentSection.servers as Record<string, Record<string, unknown>> | undefined) ?? {};
+          (currentSection?.servers as Record<string, Record<string, unknown>> | undefined) ?? {};
 
         for (const item of items) {
           if (item.currentValue === "disabled") {
@@ -212,7 +115,6 @@ function createDisabledServersSubmenu(
             const srv = servers[item.id];
             if (srv) {
               delete srv.enabled;
-              // If only `enabled` was the property, remove the whole entry
               if (Object.keys(srv).length === 0) {
                 delete servers[item.id];
               }
@@ -221,70 +123,90 @@ function createDisabledServersSubmenu(
         }
 
         writeSupiConfig({ section: "lsp", scope, cwd }, { servers });
-        done();
-        return true;
+        done("saved");
+        return;
       }
       settingsList.handleInput?.(data);
-      return true;
     },
   };
 }
 
-function createExcludeSubmenu(
-  _scope: "project" | "global",
-  _cwd: string,
-  settings: LspSettings,
-  done: (value?: string) => void,
-) {
-  const items: SettingItem[] = settings.exclude.map((pattern) => ({
-    id: pattern,
-    label: pattern,
-    currentValue: "enabled",
-    values: ["enabled", "disabled"],
-  }));
-
-  let dirty = false;
-  const container = new Container();
-  const header = new Text("Exclude Patterns — toggle off to remove", 0, 0);
-  container.addChild(header);
-
-  const footer = new Text(
-    `Add new patterns in ${CONFIG_DIR_NAME}/supi/config.json under lsp.exclude`,
-    0,
-    0,
-  );
-  container.addChild(footer);
+export function registerLspSettings(pi: ExtensionAPI): void {
+  registerDeclarativeSettings(pi, {
+    id: "lsp",
+    label: "LSP",
+    section: "lsp",
+    defaults: LSP_DEFAULTS,
+    fields: [
+      {
+        kind: "number" as const,
+        key: "severity",
+        label: "Inline Severity",
+        description: "Minimum diagnostic severity to show inline (1=errors, 4=hints)",
+        values: ["1", "2", "3", "4"],
+      },
+      {
+        kind: "stringList" as const,
+        key: "exclude",
+        label: "Exclude Patterns",
+        description: "Gitignore patterns to suppress LSP diagnostics (comma-separated)",
+      },
+      {
+        kind: "custom" as const,
+        key: "disabled_servers",
+        label: "Disabled Servers",
+        description: "Press Enter to choose which language servers to disable",
+        resolve: (scope, cwd) => {
+          const scopedDisabled = getDisabledServersFromConfig(scope, cwd);
+          const otherScope = scope === "project" ? "global" : "project";
+          const otherDisabled =
+            scope === "project" ? getDisabledServersFromConfig("global", cwd) : new Set<string>();
+
+          // Effective disabled servers = union of both scopes (since either disables)
+          const effectiveDisabled = new Set([...scopedDisabled, ...otherDisabled]);
+          const label =
+            effectiveDisabled.size > 0 ? [...effectiveDisabled].sort().join(", ") : "none disabled";
+
+          // Source: where the override comes from
+          let source: ValueSource;
+          if (scopedDisabled.size > 0) {
+            source = scope;
+          } else if (otherDisabled.size > 0) {
+            source = otherScope as ValueSource;
+          } else {
+            source = "default";
+          }
 
-  const settingsList = new SettingsList(
-    items,
-    Math.min(items.length + 3, 15),
-    getSettingsListTheme(),
-    (id, newValue) => {
-      const idx = items.findIndex((i) => i.id === id);
-      if (idx >= 0 && items[idx].currentValue !== newValue) {
-        dirty = true;
-        items[idx].currentValue = newValue;
-      }
-    },
-    () => {},
-  );
-  container.addChild(settingsList);
+          let inheritanceSource: "global" | "default" | undefined;
+          if (scope === "project" && source === "project") {
+            inheritanceSource =
+              getDisabledServersFromConfig("global", cwd).size > 0 ? "global" : "default";
+          }
 
-  return {
-    render: (width: number) => container.render(width),
-    invalidate: () => container.invalidate(),
-    handleInput: (data: string) => {
-      if (matchesKey(data, Key.escape)) {
-        if (!dirty) {
-          done();
-          return true;
-        }
-        const enabled = items.filter((i) => i.currentValue === "enabled").map((i) => i.id);
-        done(enabled.join(", ") || undefined);
-        return true;
-      }
-      settingsList.handleInput?.(data);
-      return true;
-    },
-  };
+          return { displayValue: label, source, inheritanceSource };
+        },
+        submenu: (_currentValue, done, scope, cwd) =>
+          createDisabledServersSubmenu(scope, cwd, done),
+        // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: custom field persist handler orchestrates nested config writes
+        persist: (scope, cwd, action, _helpers) => {
+          if (action.kind === "inherit" || action.kind === "resetToDefault") {
+            // Clear all per-server enable/disable entries for this scope
+            const currentSection = loadSupiConfigSectionForScope("lsp", cwd, { scope });
+            const servers =
+              (currentSection?.servers as Record<string, Record<string, unknown>> | undefined) ??
+              {};
+            for (const name of Object.keys(servers)) {
+              const srv = servers[name];
+              if (srv) {
+                delete srv.enabled;
+                if (Object.keys(srv).length === 0) delete servers[name];
+              }
+            }
+            writeSupiConfig({ section: "lsp", scope, cwd }, { servers });
+          }
+          // Explicit set actions are handled entirely inside the submenu
+        },
+      },
+    ],
+  });
 }