@mrclrchtr/supi-code-intelligence 1.16.0 → 2.0.0

package/src/api.ts

@@ -1,58 +1,51 @@
-// Reusable architecture and target-resolution helpers for peer extensions.
-// Non-provider contracts for the code-understanding stack.
+// Public type surface for @mrclrchtr/supi-code-intelligence.
+// Types only — no implementation exports.
 
-// Provider contracts re-exported from the shared runtime for convenience.
+// Provider contracts and shared canonical types from the shared runtime.
 export type {
+  CalleesData,
+  CapabilityState,
+  CodeLocation,
+  CodePosition,
+  CodeResult,
+  CodeSymbol,
+  ConfidenceMode,
+  ExportData,
+  ImportData,
+  NodeAtData,
+  OutlineData,
   SemanticProvider,
+  SemanticProvider as SemanticSubstrate,
+  SourceRange,
   StructuralProvider,
+  StructuralProvider as StructuralSubstrate,
   StructuralResult,
 } from "@mrclrchtr/supi-code-runtime/api";
-export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
-// Architecture model hosted locally in supi-code-intelligence.
+// Architecture model types.
 export type {
   ArchitectureModel,
   DependencyEdge,
   ModuleInfo,
-} from "./model.ts";
-export {
-  buildArchitectureModel,
-  findModuleForPath,
-  getDependencies,
-  getDependents,
-} from "./model.ts";
-// Substrate adapters (type aliases for provider contracts)
+} from "./analysis/architecture/model.ts";
+// Code provider types.
+export type { CodeProvider, CodeProviderState } from "./analysis/provider.ts";
+// Target resolution types.
 export type {
-  SemanticSubstrate,
-  StructuralSubstrate,
-} from "./substrates/types.ts";
-export type { ResolvedTarget, TargetResolutionResult } from "./target-resolution.ts";
-export {
-  normalizePath,
-  resolveAnchoredTarget,
-  resolveSymbolTarget,
-  toZeroBased,
-} from "./target-resolution.ts";
-// Shared canonical types
+  ResolvedTargetData,
+  ResolvedTargetGroupData,
+  TargetOutcome,
+} from "./analysis/target/types.ts";
+// Code-intelligence-specific result types.
 export type {
   AffectedDetails,
   BriefDetails,
-  CalleesData,
   CodeIntelResult,
-  CodeLocation,
-  CodePosition,
-  CodeResult,
-  CodeSymbol,
-  ConfidenceMode,
+  ContextDetails,
   DisambiguationCandidate,
-  ExportData,
-  ImportData,
-  MapDetails,
-  NodeAtData,
-  OutlineData,
-  ProviderAvailability,
+  HealthDetails,
+  ImpactDetails,
+  InspectDetails,
+  ResolveDetails,
   SearchDetails,
-  SourceRange,
-} from "./types.ts";
-// Code provider — reads capabilities from the shared workspace runtime.
-export type { CodeProvider, CodeProviderState } from "./workspace/request-context.ts";
-export { getCodeProvider } from "./workspace/request-context.ts";
+  TestSurfaceDetails,
+} from "./types/index.ts";

package/src/app/app.ts

@@ -0,0 +1,125 @@
+/**
+ * Code-intelligence app composition root.
+ *
+ * Creates the app object that wires the workspace manager, exposes
+ * registration hooks used by the extension entrypoint, and coordinates
+ * feature wiring.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { WorkspaceCodeIntelligenceSession } from "../session/session.ts";
+import { WorkspaceManager } from "./manager.ts";
+
+/**
+ * The code-intelligence app object.
+ *
+ * Exposes:
+ * - `getSession(cwd)` — retrieve a session (undefined if none)
+ * - `createSession(cwd)` — get or create a session for a workspace
+ * - `releaseSession(cwd)` — remove a session
+ * - `shutdown()` — clear all sessions
+ *
+ * The app does NOT replace the shared capability broker in
+ * @mrclrchtr/supi-code-runtime — it coordinates local session state
+ * around it.
+ */
+export interface CodeIntelligenceApp {
+  /** Get a session by cwd, or undefined. */
+  getSession(cwd: string): WorkspaceCodeIntelligenceSession | undefined;
+  /** Get or create a session for the given cwd. */
+  createSession(cwd: string): WorkspaceCodeIntelligenceSession;
+  /** Release a session for the given cwd. */
+  releaseSession(cwd: string): void;
+  /** Release all sessions. */
+  shutdown(): void;
+}
+
+/**
+ * Create a simple session cache for tests and ad-hoc usage.
+ *
+ * Returns `{ getOrCreate, clear }` — sessions are cached per cwd so
+ * that targets registered by one tool call are visible to subsequent
+ * tool calls. Production code should use the app-managed sessions
+ * passed through `CodeIntelToolExecCtx.session` instead.
+ */
+export function createSessionCache(): {
+  getOrCreate(cwd: string): WorkspaceCodeIntelligenceSession;
+  clear(): void;
+} {
+  const sessions = new Map<string, WorkspaceCodeIntelligenceSession>();
+  return {
+    getOrCreate(cwd: string): WorkspaceCodeIntelligenceSession {
+      let session = sessions.get(cwd);
+      if (!session) {
+        session = new WorkspaceCodeIntelligenceSession(cwd);
+        sessions.set(cwd, session);
+      }
+      return session;
+    },
+    clear(): void {
+      sessions.clear();
+    },
+  };
+}
+
+/**
+ * Create the code-intelligence app and wire it to pi lifecycle events.
+ *
+ * Registers:
+ * - `session_start` — creates a session for the new cwd, checks branch
+ *   for existing overview
+ * - `session_shutdown` — releases all sessions and clears per-session stores
+ */
+export function createCodeIntelligenceApp(pi: ExtensionAPI): CodeIntelligenceApp {
+  const manager = new WorkspaceManager();
+  const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
+
+  pi.on("session_start", (_event, ctx) => {
+    const session = manager.getOrCreateSession(ctx.cwd);
+
+    // Check if the branch already contains an overview
+    const branch = ctx.sessionManager.getBranch();
+    for (const entry of branch) {
+      if (
+        entry.type === "custom_message" &&
+        (entry as { customType?: string }).customType === OVERVIEW_CUSTOM_TYPE
+      ) {
+        session.hasInjectedOverview = true;
+        break;
+      }
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    // Clear per-session stores before releasing sessions
+    for (const session of manager.allSessions()) {
+      session.clearStores();
+    }
+    manager.shutdown();
+  });
+
+  return {
+    getSession(cwd: string): WorkspaceCodeIntelligenceSession | undefined {
+      return manager.getSession(cwd);
+    },
+
+    createSession(cwd: string): WorkspaceCodeIntelligenceSession {
+      return manager.getOrCreateSession(cwd);
+    },
+
+    releaseSession(cwd: string): void {
+      const session = manager.getSession(cwd);
+      if (session) {
+        session.clearStores();
+      }
+      manager.releaseSession(cwd);
+    },
+
+    shutdown(): void {
+      for (const session of manager.allSessions()) {
+        session.clearStores();
+      }
+      manager.shutdown();
+    },
+  };
+}

package/src/app/manager.ts

@@ -0,0 +1,65 @@
+/**
+ * Workspace-session lifecycle management.
+ *
+ * Owns per-cwd workspace session instances. Sessions are created
+ * once per cwd and reused until explicitly released or shut down.
+ *
+ * Does NOT own the shared capability broker in @mrclrchtr/supi-code-runtime
+ * — sessions read from it.
+ */
+
+import { WorkspaceCodeIntelligenceSession } from "../session/session.ts";
+
+/**
+ * Manages per-cwd workspace session instances.
+ */
+export class WorkspaceManager {
+  /** Active sessions keyed by cwd. */
+  readonly #sessions = new Map<string, WorkspaceCodeIntelligenceSession>();
+
+  /**
+   * Get the session for a cwd, or undefined if none exists.
+   */
+  getSession(cwd: string): WorkspaceCodeIntelligenceSession | undefined {
+    return this.#sessions.get(cwd);
+  }
+
+  /**
+   * Get or create a session for the given cwd.
+   * Returns the existing session if one already exists for this cwd.
+   */
+  getOrCreateSession(cwd: string): WorkspaceCodeIntelligenceSession {
+    let session = this.#sessions.get(cwd);
+    if (!session) {
+      session = new WorkspaceCodeIntelligenceSession(cwd);
+      this.#sessions.set(cwd, session);
+    }
+    return session;
+  }
+
+  /**
+   * Release a session for a specific cwd.
+   * Does NOT affect the shared capability broker.
+   */
+  releaseSession(cwd: string): void {
+    this.#sessions.delete(cwd);
+  }
+
+  /**
+   * Release all sessions.
+   * Does NOT affect the shared capability broker.
+   */
+  shutdown(): void {
+    this.#sessions.clear();
+  }
+
+  /** Get the number of active sessions. */
+  get size(): number {
+    return this.#sessions.size;
+  }
+
+  /** Iterate over all active sessions. */
+  allSessions(): IterableIterator<WorkspaceCodeIntelligenceSession> {
+    return this.#sessions.values();
+  }
+}

package/src/extension.ts

@@ -1 +1,132 @@
-export { default } from "./code-intelligence.ts";
+// Code Intelligence extension entry point — registers the focused code-intelligence tools,
+// the LSP adapter with diagnostics, overrides, and settings, and the unified /supi-ci-status command.
+
+import type { BeforeAgentStartEventResult, ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { buildArchitectureModel } from "./analysis/architecture/discovery.ts";
+import {
+  evaluateCoverageWarnings,
+  gatherCoverageEvalInput,
+} from "./analysis/coverage/coverage-warnings.ts";
+import { createCodeIntelligenceApp } from "./app/app.ts";
+import type { WorkspaceCodeIntelligenceSession } from "./session/session.ts";
+import { registerDiagnosticInjectionHandlers } from "./substrate/lsp/diagnostic-injection.ts";
+import { registerLspSessionLifecycle } from "./substrate/lsp/lifecycle.ts";
+import { registerLspAwareToolOverrides } from "./substrate/lsp/overrides.ts";
+import { registerWorkspaceRecoveryHandler } from "./substrate/lsp/recovery.ts";
+import { registerLspSettings } from "./substrate/lsp/settings.ts";
+import { createLspAdapterState } from "./substrate/lsp/state.ts";
+import {
+  createTsAdapterState,
+  registerTsSessionLifecycle,
+} from "./substrate/tree-sitter/lifecycle.ts";
+import { registerCodeIntelligenceTools } from "./tool/register.ts";
+import { registerLspFooterContribution } from "./ui/footer.ts";
+import { renderOverview } from "./ui/markdown/overview.ts";
+import { buildOverviewData } from "./ui/markdown/overview-data.ts";
+import { registerLspMessageRenderer } from "./ui/message-renderer.ts";
+import { registerCiStatusCommand } from "./ui/status-command.ts";
+
+const OVERVIEW_CUSTOM_TYPE = "code-intelligence-overview";
+
+export default function codeIntelligenceExtension(
+  pi: ExtensionAPI,
+  getOrCreateSession?: (cwd: string) => WorkspaceCodeIntelligenceSession,
+) {
+  const app = createCodeIntelligenceApp(pi);
+
+  const lspState = createLspAdapterState();
+  const tsState = createTsAdapterState();
+
+  // ── Substrate wiring ──────────────────────────────────────────────
+  registerLspSettings();
+  registerLspSessionLifecycle(pi, lspState);
+  registerLspAwareToolOverrides(pi, lspState);
+  registerDiagnosticInjectionHandlers(pi, lspState);
+  registerWorkspaceRecoveryHandler(pi, lspState);
+  registerTsSessionLifecycle(pi, tsState);
+
+  // ── Attach controller refs to sessions on startup (ADR 0008) ──────
+  pi.on("session_start", (_event, ctx) => {
+    const session = app.getSession(ctx.cwd);
+    if (!session) return;
+    if (lspState.controller) session.lspController = lspState.controller;
+    if (tsState.controller) session.tsController = tsState.controller;
+  });
+
+  // ── Tool registration ─────────────────────────────────────────────
+  registerCodeIntelligenceTools(
+    pi,
+    getOrCreateSession ?? ((cwd) => app.getSession(cwd) ?? app.createSession(cwd)),
+  );
+
+  // ── UI registration ───────────────────────────────────────────────
+  registerLspMessageRenderer(pi);
+  registerCiStatusCommand(pi);
+  registerLspFooterContribution(lspState);
+
+  // ── Coverage warning emission ─────────────────────────────────────
+  pi.on(
+    "before_agent_start",
+    async (_event, ctx): Promise<BeforeAgentStartEventResult | undefined> => {
+      const session = app.getSession(ctx.cwd);
+      if (!session) return;
+
+      const report = evaluateCoverageWarnings(
+        gatherCoverageEvalInput(ctx.cwd, session.lspController),
+      );
+      const pending = session.coverageWarningState.getPendingWarnings(report);
+      if (pending.length === 0) return;
+
+      const lines = [
+        '<extension-context source="supi-code-intelligence">',
+        "Code intelligence coverage is degraded:",
+      ];
+      for (const w of pending) {
+        const lang = w.language ? `[${w.language}] ` : "";
+        const detail = w.detail ? ` — ${w.detail}` : "";
+        lines.push(`- ${lang}${w.message}${detail}`);
+      }
+      lines.push("</extension-context>");
+      const warningContext = lines.join("\n");
+
+      return {
+        message: {
+          customType: "code-intelligence-coverage",
+          display: true,
+          content: warningContext,
+        },
+        systemPrompt:
+          (await ctx.getSystemPrompt()) +
+          `\n\nThe code intelligence stack has degraded coverage. This means some code-understanding tools (code_* tools) may return limited or structural-only information. The agent should still attempt using them, but be aware that semantic coverage for some languages may be unavailable.`,
+      };
+    },
+  );
+
+  // ── Overview injection — uses the app-managed session state ────────
+  pi.on(
+    "before_agent_start",
+    async (_event, ctx): Promise<BeforeAgentStartEventResult | undefined> => {
+      const session = app.getSession(ctx.cwd);
+      if (!session) return;
+      if (session.hasInjectedOverview) return;
+      session.hasInjectedOverview = true;
+
+      const model = await buildArchitectureModel(ctx.cwd);
+      if (!model || model.modules.length === 0) return;
+
+      const data = buildOverviewData(model);
+      if (!data) return;
+
+      const overview = renderOverview(data);
+      if (!overview) return;
+
+      return {
+        message: {
+          customType: OVERVIEW_CUSTOM_TYPE,
+          display: false,
+          content: overview,
+        },
+      };
+    },
+  );
+}

package/src/index.ts

@@ -1,57 +1 @@
-// Package root exports for @mrclrchtr/supi-code-intelligence.
-// Peer extensions can import these APIs for programmatic access.
-
-// Provider contracts re-exported from the shared runtime for convenience.
-export type {
-  SemanticProvider,
-  StructuralProvider,
-  StructuralResult,
-} from "@mrclrchtr/supi-code-runtime/api";
-export { generateFocusedBrief, generateOverview, generateProjectBrief } from "./brief.ts";
-export type {
-  ArchitectureModel,
-  DependencyEdge,
-  ModuleInfo,
-} from "./model.ts";
-export {
-  buildArchitectureModel,
-  findModuleForPath,
-  getDependencies,
-  getDependents,
-} from "./model.ts";
-// Substrate adapters (type aliases for provider contracts)
-export type {
-  SemanticSubstrate,
-  StructuralSubstrate,
-} from "./substrates/types.ts";
-export type { ResolvedTarget, TargetResolutionResult } from "./target-resolution.ts";
-export {
-  normalizePath,
-  resolveAnchoredTarget,
-  resolveSymbolTarget,
-  toZeroBased,
-} from "./target-resolution.ts";
-// Shared canonical types
-export type {
-  AffectedDetails,
-  BriefDetails,
-  CalleesData,
-  CodeIntelResult,
-  CodeLocation,
-  CodePosition,
-  CodeResult,
-  CodeSymbol,
-  ConfidenceMode,
-  DisambiguationCandidate,
-  ExportData,
-  ImportData,
-  MapDetails,
-  NodeAtData,
-  OutlineData,
-  ProviderAvailability,
-  SearchDetails,
-  SourceRange,
-} from "./types.ts";
-// Code provider — reads capabilities from the shared workspace runtime.
-export type { CodeProvider, CodeProviderState } from "./workspace/request-context.ts";
-export { getCodeProvider } from "./workspace/request-context.ts";
+export type * from "./api.ts";

package/src/session/refactor-plans.ts

@@ -0,0 +1,82 @@
+/**
+ * Refactor plan storage — per-session map for plan id → plan data.
+ *
+ * Plans are stored in-memory on the WorkspaceSession for the session lifetime.
+ * The store map is passed in from the caller; this module provides pure
+ * functions without module-level state.
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import type { RefactorOperation, WorkspaceEdit } from "@mrclrchtr/supi-code-runtime/api";
+
+export interface RefactorPlan {
+  id: string;
+  operation: Exclude<RefactorOperation, "rename">;
+  newName?: string;
+  destination?: string;
+  targetFile: string;
+  targetLine: number;
+  targetCharacter: number;
+  edits: WorkspaceEdit;
+  fileFingerprints: Array<{ file: string; fingerprint: string }>;
+  createdAt: number;
+}
+
+/** Compute a SHA-256 hex fingerprint for a file's current contents. */
+export function computeFileFingerprint(file: string): string {
+  try {
+    const content = readFileSync(file, "utf-8");
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return "unreadable";
+  }
+}
+
+/** Generate a stable plan id from operation details. */
+// biome-ignore lint/complexity/useMaxParams: plan id construction needs all positional args
+export function generatePlanId(
+  operation: string,
+  file: string,
+  line: number,
+  character: number,
+  discriminator: string = "",
+): string {
+  const hash = createHash("sha256")
+    .update(`${operation}:${file}:${line}:${character}:${discriminator}:${Date.now()}`)
+    .digest("hex")
+    .slice(0, 12);
+  return `plan-${hash}`;
+}
+
+/** Store a plan in the given session-scoped map and return its id. */
+export function storePlan(store: Map<string, RefactorPlan>, plan: RefactorPlan): string {
+  store.set(plan.id, plan);
+  return plan.id;
+}
+
+/** Retrieve a plan by id from the given session-scoped map, or undefined if not found. */
+export function getPlan(store: Map<string, RefactorPlan>, id: string): RefactorPlan | undefined {
+  return store.get(id);
+}
+
+/** Remove a plan from the given session-scoped map after successful apply. */
+export function removePlan(store: Map<string, RefactorPlan>, id: string): void {
+  store.delete(id);
+}
+
+/** Check if a plan is still fresh (all file fingerprints match). */
+export function isPlanFresh(
+  plan: RefactorPlan,
+): { fresh: true } | { fresh: false; reason: string } {
+  for (const fp of plan.fileFingerprints) {
+    const current = computeFileFingerprint(fp.file);
+    if (current !== fp.fingerprint) {
+      return {
+        fresh: false,
+        reason: `File ${fp.file} has changed since the plan was generated. Regenerate with code_refactor_plan.`,
+      };
+    }
+  }
+  return { fresh: true };
+}