septum 0.1.6 → 0.1.7

package/src/mcp/server.ts

@@ -1,5 +1,5 @@
-import { existsSync, watch, type FSWatcher } from "node:fs";
-import { extname, relative, resolve } from "node:path";
+import { existsSync, statSync, watch, type FSWatcher } from "node:fs";
+import { relative, resolve } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -12,6 +12,7 @@ import { ConfigLoader } from "../core/config/loader.ts";
 import { SeptumDatabase } from "../core/database/client.ts";
 import { SeptumRepository } from "../core/database/repository.ts";
 import { IngestionPipeline } from "../core/ingestion/pipeline.ts";
+import { ASTParserEngine } from "../core/parser/tree-sitter.ts";
 import { SessionManager } from "../core/session/session-manager.ts";
 import { SeptumTelemetry } from "../core/telemetry/telemetry.ts";
 import { handleCheckBoundary } from "./tools/check-boundary.ts";
@@ -52,6 +53,8 @@ interface WorkspaceContext {
   repo: SeptumRepository;
   evaluator: BoundaryEvaluator;
   pipeline: IngestionPipeline;
+  ready: Promise<void>;
+  watcher: { flush: () => Promise<void>; close: () => void };
 }
 
 const workspaceContextCache = new Map<string, WorkspaceContext>();
@@ -127,6 +130,87 @@ export function extractPathHint(args: unknown): string | undefined {
   return undefined;
 }
 
+function createWorkspaceWatcher(root: string, repo: SeptumRepository, pipeline: IngestionPipeline, ready: Promise<void>) {
+  const pending = new Set<string>();
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let flushing: Promise<void> | null = null;
+  let closed = false;
+  let needsFullSync = false;
+  const ignored = new Set(["node_modules", "vendor", ".git", ".septum", ".strata", "dist", "build", ".output", ".nuxt", ".next", ".cache", "coverage", ".turbo"]);
+  let watcher: FSWatcher | null = null;
+  let polling: ReturnType<typeof setInterval> | null = null;
+
+  const flush = async (): Promise<void> => {
+    if (timer) { clearTimeout(timer); timer = null; }
+    if (flushing) return flushing;
+    flushing = (async () => {
+      await ready;
+      if (!closed && (!watcher || needsFullSync || repo.getMeta("sync_error"))) {
+        needsFullSync = false;
+        await pipeline.run(ConfigLoader.load(undefined, root), { verifyContent: true });
+        repo.setMeta("sync_error", "");
+      }
+      while (!closed && pending.size > 0) {
+        const paths = [...pending];
+        pending.clear();
+        const config = ConfigLoader.load(undefined, root);
+        for (const filename of paths) {
+          const target = resolve(root, filename);
+          const relPath = relative(root, target).replace(/\\/g, "/");
+          if (!existsSync(target)) {
+            repo.runInTransaction(() => { repo.deleteFileByPath(relPath); repo.clearVerticalSlices();
+              const unsupported = JSON.parse(repo.getMeta("unsupported_files") || "[]") as string[];
+              repo.setMeta("unsupported_files", JSON.stringify(unsupported.filter(path => path !== relPath))); });
+          } else {
+            await pipeline.ingestFile(target, config);
+          }
+        }
+      }
+    })();
+    try { await flushing; } finally { flushing = null; }
+  };
+
+  const usePolling = (error: unknown) => {
+    watcher?.close();
+    watcher = null;
+    repo.setMeta("watcher_mode", "polling");
+    console.error(`[Septum Watcher Warning] Using polling: ${String(error)}`);
+    if (!polling) polling = setInterval(() => {
+      void flush().catch(failure => repo.setMeta("sync_error", String(failure)));
+    }, 1000);
+  };
+
+  try {
+    watcher = watch(root, { recursive: true }, (_event, filename) => {
+      if (!filename || closed) return;
+      const norm = filename.replace(/\\/g, "/");
+      if (norm.split("/").some(segment => ignored.has(segment))) return;
+      const target = resolve(root, norm);
+      let directory = false;
+      try { directory = statSync(target).isDirectory(); } catch { /* The path may have been removed before the event arrives. */ }
+      if (directory || (!ASTParserEngine.isSourceFile(norm) && (repo.getAllFiles().some(file => file.path.startsWith(norm + "/")) || (JSON.parse(repo.getMeta("unsupported_files") || "[]") as string[]).some(file => file.startsWith(norm + "/"))))) {
+        needsFullSync = true;
+      } else if (ASTParserEngine.isSourceFile(norm)) {
+        pending.add(norm);
+      } else {
+        return;
+      }
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        void flush().catch(error => {
+          repo.setMeta("sync_error", String(error));
+          console.error(`[Septum Watcher Warning] ${String(error)}`);
+        });
+      }, 300);
+    });
+    repo.setMeta("watcher_mode", "native");
+    watcher.on("error", usePolling);
+  } catch (error) {
+    usePolling(error);
+  }
+  return { flush, close: () => { closed = true; if (timer) clearTimeout(timer); if (polling) clearInterval(polling); watcher?.close(); } };
+}
+
 function getWorkspaceContext(pathHint?: string): WorkspaceContext {
   const root = resolveWorkspaceRoot(pathHint);
   let ctx = workspaceContextCache.get(root);
@@ -142,13 +226,16 @@ function getWorkspaceContext(pathHint?: string): WorkspaceContext {
   const evaluator = new BoundaryEvaluator(repo, new ModuleResolver(root, repo));
   const pipeline = new IngestionPipeline(repo, root);
 
-  ctx = { root, config, db, repo, evaluator, pipeline };
+  const ready = pipeline.run(config, { verifyContent: true }).then(() => {});
+  const watcher = createWorkspaceWatcher(root, repo, pipeline, ready);
+  ctx = { root, config, db, repo, evaluator, pipeline, ready, watcher };
   workspaceContextCache.set(root, ctx);
   return ctx;
 }
 
 export async function runMCPServer(): Promise<void> {
   const initialCtx = getWorkspaceContext();
+  await initialCtx.ready;
 
   const server = new Server(
     {
@@ -571,6 +658,11 @@ export async function runMCPServer(): Promise<void> {
     const startTime = performance.now();
     const pathHint = extractPathHint(args as Record<string, any>);
     const ctx = getWorkspaceContext(pathHint);
+    await ctx.ready;
+    await ctx.watcher.flush();
+    if (ctx.repo.getMeta("sync_error")) throw new Error(`Workspace index synchronization failed: ${ctx.repo.getMeta("sync_error")}`);
+    ctx.config = ConfigLoader.load(undefined, ctx.root);
+    ctx.evaluator.getResolver().setRepository(ctx.repo);
 
     const activeSession = SessionManager.getActiveSession(ctx.root);
     const sessionPayload = activeSession
@@ -772,7 +864,7 @@ export async function runMCPServer(): Promise<void> {
         metrics: { bytes_out: bytesOut, lines_out: linesOut },
         session: sessionPayload,
         status: (response as { isError?: boolean } | undefined)?.isError ? "error" : "success",
-      });
+      }, ctx.root);
 
       return response;
     } catch (err) {
@@ -790,7 +882,7 @@ export async function runMCPServer(): Promise<void> {
           message: errorInstance.message,
           stack: errorInstance.stack,
         },
-      });
+      }, ctx.root);
 
       return {
         isError: true,
@@ -806,84 +898,10 @@ export async function runMCPServer(): Promise<void> {
 
   const transport = new StdioServerTransport();
 
-  // In-process transparent background watcher for auto-syncing codebase changes
-  let fsWatcher: FSWatcher | null = null;
-  let debounceTimer: NodeJS.Timeout | null = null;
-  const SUPPORTED_EXTENSIONS = new Set([".ts", ".js", ".tsx", ".jsx", ".php", ".py", ".go"]);
-  const IGNORED_SEGMENTS = new Set([
-    "node_modules",
-    ".git",
-    ".septum",
-    ".strata",
-    "dist",
-    ".output",
-    ".nuxt",
-    ".next",
-    ".cache",
-    "coverage",
-    ".turbo",
-  ]);
-
-  try {
-    const bgPipeline = initialCtx.pipeline;
-    const watchRoot = initialCtx.root;
-
-    fsWatcher = watch(watchRoot, { recursive: true }, (_event, filename) => {
-      if (!filename) return;
-
-      const norm = filename.replace(/\\/g, "/");
-      const parts = norm.split("/");
-      if (parts.some((p) => IGNORED_SEGMENTS.has(p))) return;
-
-      const ext = extname(norm).toLowerCase();
-      if (!SUPPORTED_EXTENSIONS.has(ext)) return;
-
-      if (debounceTimer) clearTimeout(debounceTimer);
-      debounceTimer = setTimeout(async () => {
-        try {
-          const freshConfig = ConfigLoader.load(undefined, watchRoot);
-          const targetPath = resolve(watchRoot, filename);
-          const relPath = relative(watchRoot, targetPath).replace(/\\/g, "/");
-          if (!existsSync(targetPath)) {
-            if (typeof (initialCtx.repo as any).deleteFileByPath === "function") {
-              (initialCtx.repo as any).deleteFileByPath(relPath);
-            } else if (typeof initialCtx.repo.deleteFile === "function") {
-              initialCtx.repo.deleteFile(relPath);
-            }
-            return;
-          }
-          const updated = await bgPipeline.ingestFile(targetPath, freshConfig);
-          if (updated) {
-            console.error(
-              `[Septum Watcher] Auto-synced modified file '${filename}' via incremental delta sync.`
-            );
-          }
-        } catch (err: unknown) {
-          const msg = err instanceof Error ? err.message : String(err);
-          console.error(`[Septum Watcher Warning] Background auto-sync failed: ${msg}`);
-        }
-      }, 300);
-    });
-
-    fsWatcher.on("error", (err: Error) => {
-      console.error(`[Septum Watcher] File watcher error: ${err.message}`);
-    });
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[Septum Watcher Warning] Could not start filesystem watcher: ${msg}`);
-  }
-
   const cleanup = () => {
-    if (debounceTimer) clearTimeout(debounceTimer);
-    if (fsWatcher) {
-      try {
-        fsWatcher.close();
-      } catch {
-        // Ignore watcher close errors during shutdown
-      }
-    }
     for (const ctx of workspaceContextCache.values()) {
       try {
+        ctx.watcher.close();
         ctx.db.close();
       } catch (err) {
         // Ignore close error during shutdown
@@ -896,16 +914,9 @@ export async function runMCPServer(): Promise<void> {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   process.on("beforeExit", () => {
-    if (debounceTimer) clearTimeout(debounceTimer);
-    if (fsWatcher) {
-      try {
-        fsWatcher.close();
-      } catch {
-        // Ignore watcher close errors
-      }
-    }
     for (const ctx of workspaceContextCache.values()) {
       try {
+        ctx.watcher.close();
         ctx.db.close();
       } catch {
         // Ignore close error

package/src/mcp/tools/check-boundary.ts

@@ -1,4 +1,5 @@
-import { execSync } from "node:child_process";
+import { relative, resolve } from "node:path";
+import { auditStagedFiles } from "../../core/boundary/staged-auditor.ts";
 import type { BoundaryEvaluator } from "../../core/boundary/evaluator.ts";
 import type { ValidatedSeptumConfig } from "../../core/config/schema.ts";
 import type { SeptumRepository } from "../../core/database/repository.ts";
@@ -7,7 +8,7 @@ import { normalizeBoundaryArgs, type CheckBoundaryArgs } from "../schemas.ts";
 
 export type { CheckBoundaryArgs } from "../schemas.ts";
 
-export function handleCheckBoundary(
+export async function handleCheckBoundary(
   evaluator: BoundaryEvaluator,
   config: ValidatedSeptumConfig,
   rawArgs: CheckBoundaryArgs & Record<string, unknown>,
@@ -19,6 +20,17 @@ export function handleCheckBoundary(
   const proposedImports = args.proposed_imports ?? [];
   const featureKey = args.feature_key;
 
+  const unsupported = JSON.parse(repo?.getMeta("unsupported_files") || "[]") as string[];
+  const requested = [...(Array.isArray(args.file_path) ? args.file_path : args.file_path ? [args.file_path] : []), ...(args.file_paths || [])]
+    .map(file => relative(root, resolve(root, file)).replace(/\\/g, "/"));
+  const relevantUnsupported = unsupported.filter(file =>
+    (!args.domain || evaluator.resolveSourceDomain(file, config) === args.domain) &&
+    (requested.length === 0 || requested.includes(file))
+  );
+  if (relevantUnsupported.length > 0 && args.scope !== "staged" && !args.staged) {
+    return { content: [{ type: "text" as const, text: JSON.stringify({ status: "unknown", unsupported_files: relevantUnsupported, message: "Boundary audit is incomplete because source files have no supported parser." }) }] };
+  }
+
   const filesToCheck: string[] = [];
   if (args.file_paths && Array.isArray(args.file_paths) && args.file_paths.length > 0) {
     filesToCheck.push(...args.file_paths);
@@ -36,20 +48,7 @@ export function handleCheckBoundary(
       args.scope ?? (args.staged ? "staged" : args.domain ? "domain" : "all");
 
     if (effectiveScope === "staged") {
-      let stagedFiles: string[] = [];
-      try {
-        const gitOut = execSync("git diff --name-only --cached", {
-          cwd: root,
-          encoding: "utf-8",
-          timeout: 5000,
-        });
-        stagedFiles = gitOut
-          .split("\n")
-          .map((f) => f.trim())
-          .filter(Boolean);
-      } catch {
-        stagedFiles = [];
-      }
+      const { files: stagedFiles, violations: stagedViolations } = await auditStagedFiles(evaluator, config, root, featureKey, repo);
 
       if (stagedFiles.length === 0) {
         return {
@@ -75,23 +74,6 @@ export function handleCheckBoundary(
         };
       }
 
-      const codebaseViolations = evaluator.auditCodebase(config);
-      const stagedNormalized = new Set(
-        stagedFiles.map((f) => f.replace(/\\/g, "/").replace(/^\.\//, ""))
-      );
-      const stagedViolations: BoundaryViolation[] = [];
-
-      for (const filePath of stagedFiles) {
-        const evalViolations = evaluator.evaluate(filePath, proposedImports, featureKey, config);
-        stagedViolations.push(...evalViolations);
-      }
-      for (const v of codebaseViolations) {
-        const normFile = v.file.replace(/\\/g, "/").replace(/^\.\//, "");
-        if (stagedNormalized.has(normFile)) {
-          stagedViolations.push(v);
-        }
-      }
-
       const filteredViolations = args.domain
         ? stagedViolations.filter(
             (v) =>

package/src/mcp/tools/get-domain-catalog.ts

@@ -15,6 +15,10 @@ export function handleGetDomainCatalog(
 ) {
   const targetRoot = args.workspace_path || workspaceRoot || (repo as any)?.projectRoot || process.cwd();
   const domainName = args.domain ?? args.name;
+  const indexStatus = {
+    unsupported_files: JSON.parse(repo.getMeta("unsupported_files") || "[]"),
+    watcher_mode: repo.getMeta("watcher_mode") || "manual",
+  };
 
   if (!domainName) {
     const allDomains = repo.getAllDomains();
@@ -55,6 +59,7 @@ export function handleGetDomainCatalog(
         : repo.getAllVerticalSlices().length;
 
     const macroMap = {
+      index_status: indexStatus,
       telescope_view: {
         project_type: projectType,
         framework,
@@ -129,7 +134,7 @@ export function handleGetDomainCatalog(
     content: [
       {
         type: "text" as const,
-        text: JSON.stringify(catalog, null, 2),
+        text: JSON.stringify({ ...catalog, index_status: indexStatus }, null, 2),
       },
     ],
   };

package/src/mcp/tools/locate-symbol.ts

@@ -100,18 +100,41 @@ export async function handleLocateSymbol(
     }
   }
 
+  const exactLineCount = result.exact_symbol
+    ? result.exact_symbol.line_end - result.exact_symbol.line_start + 1
+    : 0;
+  const complexitySmell =
+    exactLineCount > 300
+      ? {
+          is_high_complexity: true,
+          threshold: 300,
+          total_lines: exactLineCount,
+          warning: `Symbol '${result.exact_symbol?.name}' spans ${exactLineCount} lines (exceeds 300-line threshold). Candidate for decomposition/refactoring.`,
+        }
+      : undefined;
+
   const suggestions = (result.suggestions || []).slice(0, limit);
-  const summary = result.found
+  let summary = result.found
     ? `[FOUND] ${result.exact_symbol?.name || query} in ${result.file_path} (lines ${result.exact_symbol?.line_start}-${result.exact_symbol?.line_end})`
     : `[NOT FOUND] Symbol '${query}' not found. ${suggestions.length > 0 ? `Top suggestions: ${suggestions.map((s) => s.name).slice(0, 3).join(", ")}` : "No close suggestions."}`;
 
+  if (complexitySmell) {
+    summary += ` | ⚠️ High-Complexity Smell: spans ${exactLineCount} lines (> 300L)`;
+  }
+
   const payload = {
     status: result.found ? "success" : "not_found",
     found: result.found,
     query,
     file_path: result.file_path || null,
     container_name: result.container_name || null,
-    exact_symbol: result.exact_symbol || null,
+    exact_symbol: result.exact_symbol
+      ? {
+          ...result.exact_symbol,
+          total_lines: exactLineCount,
+        }
+      : null,
+    complexity_smell: complexitySmell,
     sibling_methods: result.sibling_methods || [],
     suggestions,
     summary,

package/src/mcp/tools/register-feature.ts

@@ -41,6 +41,14 @@ export async function handleRegisterFeature(
     output_contract: args.output_contract || {},
   };
 
+  // Record Active Feature Session Lease (.septum/session.json)
+  SessionManager.saveActiveSession(workspaceRoot, {
+    feature_key: featureKey,
+    domain,
+    touchpoints: featureConfig.allowed_touchpoints,
+    locked_at: new Date().toISOString(),
+  });
+
   if (!config.features) {
     config.features = {};
   }
@@ -59,13 +67,7 @@ export async function handleRegisterFeature(
     }
   }
 
-  // Record Active Feature Session Lease (.septum/session.json)
-  SessionManager.saveActiveSession(workspaceRoot, {
-    feature_key: featureKey,
-    domain,
-    touchpoints: featureConfig.allowed_touchpoints,
-    locked_at: new Date().toISOString(),
-  });
+
 
   return {
     content: [

package/src/types/index.ts

@@ -129,6 +129,7 @@ export interface FileRecord {
 }
 
 export interface ActiveFeatureSession {
+  owner_id?: string;
   feature_key: string;
   domain: string;
   touchpoints: string[];
@@ -177,6 +178,7 @@ export interface ExtractedDependency {
 }
 
 export interface ParsedFileAST {
+  status?: "parsed" | "unsupported" | "degraded";
   symbols: ExtractedSymbol[];
   dependencies: ExtractedDependency[];
 }
@@ -324,6 +326,21 @@ export interface SymbolExactRange {
   total_lines: number;
 }
 
+export interface ResolvedOutboundCall {
+  symbol: string;
+  target_file?: string;
+  target_range?: SymbolExactRange;
+  domain?: string;
+  is_resolved: boolean;
+}
+
+export interface SymbolComplexitySmell {
+  is_high_complexity: boolean;
+  threshold: number;
+  total_lines: number;
+  warning: string;
+}
+
 export interface GetSymbolDetailsResponse {
   symbol: string;
   kind: SymbolKind | string;
@@ -334,6 +351,8 @@ export interface GetSymbolDetailsResponse {
   visibility?: Visibility | string;
   dependencies_injected: string[];
   outbound_calls: string[];
+  resolved_outbound_calls?: ResolvedOutboundCall[];
+  complexity_smell?: SymbolComplexitySmell;
   sibling_methods?: string[];
   connected_files?: FileConnectionsSummary;
 }
@@ -358,7 +377,7 @@ export interface GetSymbolImpactResponse {
   warning?: string;
   impact_summary: {
     total_dependents: number;
-    risk_level: "low" | "medium" | "high";
+    risk_level: "low" | "medium" | "high" | "unknown";
     affected_files_count: number;
   };
   inbound_callers: InboundCaller[];

package/src/types/wasm.d.ts

@@ -0,0 +1,4 @@
+declare module "*.wasm" {
+  const path: string;
+  export default path;
+}