septum 0.1.6 → 0.1.7

package/src/core/ingestion/pipeline.ts

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import type { ParsedFileAST } from "../../types/index.ts";
 import type { ValidatedSeptumConfig } from "../config/schema.ts";
 import type { SeptumRepository } from "../database/repository.ts";
@@ -8,6 +8,7 @@ import { SemanticSliceExtractorRegistry } from "../parser/extractors/registry.ts
 import { TopologyDetector } from "../discovery/topology-detector.ts";
 import { ASTParserEngine } from "../parser/tree-sitter.ts";
 import { CallGraphTracer } from "../resolver/call-graph-tracer.ts";
+import { ModuleResolver } from "../resolver/module-resolver.ts";
 import { computeContentHash } from "./hasher.ts";
 
 export interface IngestionMetrics {
@@ -33,13 +34,15 @@ export class IngestionPipeline {
     }
   }
 
-  public async run(config: ValidatedSeptumConfig): Promise<IngestionMetrics> {
+  public async run(config: ValidatedSeptumConfig, options: { verifyContent?: boolean } = {}): Promise<IngestionMetrics> {
+    this.ensureParserRevision();
     const startTime = performance.now();
     let filesScanned = 0;
     let filesUpdated = 0;
     let filesSkipped = 0;
     let symbolsIndexed = 0;
     let dependenciesIndexed = 0;
+    const unsupportedFiles: string[] = [];
 
     let domainNames = Object.keys(config.domains);
     const projectRoot = this.customWorkspaceRoot || process.cwd();
@@ -71,17 +74,16 @@ export class IngestionPipeline {
       const absDomainRoot = resolve(workspaceRoot, domainCfg.root);
 
       if (!existsSync(absDomainRoot)) {
+        this.repo.files.deleteFilesNotInPaths(domainId, []);
         continue;
       }
 
-      const normCurrentRoot = domainCfg.root.replace(/\\/g, "/").replace(/^\.\/?/, "");
       const childDomainRoots = domainNames
-        .filter((d) => d !== domainName)
-        .map((d) => config.domains[d].root.replace(/\\/g, "/").replace(/^\.\/?/, ""))
-        .filter((r) => {
-          if (!r) return false;
-          if (!normCurrentRoot) return true;
-          return r.startsWith(normCurrentRoot + "/");
+        .filter(name => name !== domainName)
+        .map(name => relative(workspaceRoot, resolve(workspaceRoot, config.domains[name].root)).replace(/\\/g, "/"))
+        .filter(child => {
+          const fromParent = relative(absDomainRoot, resolve(workspaceRoot, child)).replace(/\\/g, "/");
+          return fromParent !== "" && fromParent !== ".." && !fromParent.startsWith("../") && !isAbsolute(fromParent);
         });
 
       const collectedFiles = this.collectFiles(
@@ -120,12 +122,13 @@ export class IngestionPipeline {
           continue;
         }
 
-        const mtimeMs = Math.round(stat.mtimeMs);
+        const mtimeMs = stat.mtimeMs;
         const sizeBytes = stat.size;
         const existingFile = existingFilesMap.get(relPath);
 
         // Tier 1: Fast OS metadata check (inode mtime + size + domain match)
         if (
+          !options.verifyContent &&
           existingFile &&
           existingFile.domain_id === domainId &&
           existingFile.mtime_ms === mtimeMs &&
@@ -150,11 +153,17 @@ export class IngestionPipeline {
           continue;
         }
 
-        filesUpdated++;
         const lineCount = content.split("\n").length;
         const archetype = detectArchetype(relPath, domainCfg.archetypes ?? {});
         const ast = await this.parserEngine.parseFile(fullPath, content);
+        if (ast.status === "unsupported") {
+          unsupportedFiles.push(relPath);
+          this.repo.deleteFileByPath(relPath);
+          continue;
+        }
+        if (ast.status === "degraded") throw new Error(`Cannot reliably index '${relPath}': parser is degraded.`);
 
+        filesUpdated++;
         pendingUpdates.push({
           fullPath,
           relPath,
@@ -229,6 +238,7 @@ export class IngestionPipeline {
       this.repo.setMeta("files_updated", String(filesUpdated));
       this.repo.setMeta("symbols_indexed", String(symbolsIndexed));
       this.repo.setMeta("dependencies_indexed", String(dependenciesIndexed));
+      this.repo.setMeta("unsupported_files", JSON.stringify(unsupportedFiles));
     });
 
     return {
@@ -514,15 +524,27 @@ export class IngestionPipeline {
   }
 
   private isSourceFile(path: string): boolean {
-    return /\.(ts|tsx|js|jsx|mjs|cjs|php|py|go|rs|vue|astro|svelte)$/i.test(path);
+    return ASTParserEngine.isSourceFile(path);
+  }
+
+  private ensureParserRevision(): void {
+    const revision = "2";
+    if (this.repo.getMeta("parser_revision") === revision) return;
+    this.repo.runInTransaction(() => {
+      for (const file of this.repo.getAllFiles()) {
+        this.repo.upsertFile(file.domain_id, file.path, file.archetype, "", file.line_count, -1, -1);
+      }
+      this.repo.clearVerticalSlices();
+      this.repo.setMeta("parser_revision", revision);
+    });
   }
 
   /**
    * JIT single-file ingestion: quickly verifies and updates a single file's AST,
    * symbols, and dependencies in SQLite if its mtime or content hash has changed.
-   * Runs in < 5ms for rapid delta sync without full project scans.
    */
   public async ingestFile(targetFilePath: string, config: ValidatedSeptumConfig): Promise<boolean> {
+    this.ensureParserRevision();
     const fullPath = resolve(targetFilePath);
     if (!existsSync(fullPath)) return false;
 
@@ -534,7 +556,7 @@ export class IngestionPipeline {
       return false;
     }
 
-    const mtimeMs = Math.round(stat.mtimeMs);
+    const mtimeMs = stat.mtimeMs;
     const sizeBytes = stat.size;
 
     const projectRoot = this.customWorkspaceRoot || process.cwd();
@@ -544,18 +566,8 @@ export class IngestionPipeline {
       return false;
     }
 
-    let targetDomainName: string | null = null;
-    let targetDomainCfg = null;
-
-    for (const [dName, dCfg] of Object.entries(config.domains)) {
-      const absRoot = resolve(projectRoot, dCfg.root).replace(/\\/g, "/");
-      const normFullPath = fullPath.replace(/\\/g, "/");
-      if (normFullPath === absRoot || normFullPath.startsWith(absRoot + "/")) {
-        targetDomainName = dName;
-        targetDomainCfg = dCfg;
-        break;
-      }
-    }
+    const targetDomainName = new ModuleResolver(projectRoot, this.repo).resolveSourceDomain(fullPath, config);
+    const targetDomainCfg = targetDomainName ? config.domains[targetDomainName] : null;
 
     if (!targetDomainName || !targetDomainCfg) {
       return false;
@@ -564,20 +576,11 @@ export class IngestionPipeline {
     const domainId = this.repo.upsertDomain(targetDomainName, targetDomainCfg);
     const existingFile = this.repo.getFileByPath(relPath);
 
-    // Tier 1: Fast OS metadata check
-    if (
-      existingFile &&
-      existingFile.mtime_ms === mtimeMs &&
-      existingFile.size_bytes === sizeBytes
-    ) {
-      return false; // Completely up to date
-    }
-
     const content = readFileSync(fullPath, "utf-8");
     const currentHash = computeContentHash(content);
 
     // Tier 2: Hash verification
-    if (existingFile && existingFile.content_hash === currentHash) {
+    if (existingFile && existingFile.domain_id === domainId && existingFile.content_hash === currentHash) {
       this.repo.updateFileMetadataOnly(existingFile.id, mtimeMs, sizeBytes);
       return false;
     }
@@ -585,6 +588,14 @@ export class IngestionPipeline {
     const lineCount = content.split("\n").length;
     const archetype = detectArchetype(relPath, targetDomainCfg.archetypes ?? {});
     const ast = await this.parserEngine.parseFile(fullPath, content);
+    if (ast.status === "unsupported") {
+      this.repo.deleteFileByPath(relPath);
+      const unsupported = new Set<string>(JSON.parse(this.repo.getMeta("unsupported_files") || "[]"));
+      unsupported.add(relPath);
+      this.repo.setMeta("unsupported_files", JSON.stringify([...unsupported]));
+      return false;
+    }
+    if (ast.status === "degraded") throw new Error(`Cannot reliably index '${relPath}': parser is degraded.`);
 
     this.repo.runInTransaction(() => {
       const fileId = this.repo.upsertFile(
@@ -598,6 +609,9 @@ export class IngestionPipeline {
       );
       this.repo.replaceFileSymbols(fileId, ast.symbols);
       this.repo.replaceFileDependencies(fileId, ast.dependencies);
+      this.repo.clearVerticalSlices();
+      const unsupported = JSON.parse(this.repo.getMeta("unsupported_files") || "[]") as string[];
+      this.repo.setMeta("unsupported_files", JSON.stringify(unsupported.filter(path => path !== relPath)));
     });
 
     return true;

package/src/core/parser/extractors/frontend.ts

@@ -123,6 +123,7 @@ export class FrontendExtractor implements CodeExtractor {
     dependencies: ExtractedDependency[]
   ): Promise<void> {
     const parsed = await this.tsExtractor.extract("component-script.ts", scriptContent);
+    if (parsed.status === "degraded") throw new Error("Cannot reliably parse component script.");
     const delta = Math.max(0, startLine - 1);
 
     for (const dep of parsed.dependencies) {

package/src/core/parser/extractors/go.ts

@@ -67,10 +67,10 @@ export class GoExtractor implements CodeExtractor {
       this.extractFromAst(rootNode, filePath, content)
     );
     if (astResult) {
-      return astResult;
+      return { ...astResult, status: "parsed" };
     }
 
-    return this.extractFallback(filePath, content);
+    return { ...this.extractFallback(filePath, content), status: "degraded" };
   }
 
   private extractFallback(filePath: string, content: string): ParsedFileAST {

package/src/core/parser/extractors/php.ts

@@ -44,10 +44,10 @@ export class PHPExtractor implements CodeExtractor {
       this.extractFromAst(rootNode, content)
     );
     if (astResult) {
-      return astResult;
+      return { ...astResult, status: "parsed" };
     }
 
-    return this.extractFallback(content);
+    return { ...this.extractFallback(content), status: "degraded" };
   }
 
   private isExternalNamespace(cleaned: string): boolean {

package/src/core/parser/extractors/python.ts

@@ -79,10 +79,10 @@ export class PythonExtractor implements CodeExtractor {
       this.extractFromAst(rootNode, content)
     );
     if (astResult) {
-      return astResult;
+      return { ...astResult, status: "parsed" };
     }
 
-    return this.extractFallback(content);
+    return { ...this.extractFallback(content), status: "degraded" };
   }
 
   private extractFallback(content: string): ParsedFileAST {

package/src/core/parser/extractors/typescript.ts

@@ -46,10 +46,10 @@ export class TypeScriptExtractor implements CodeExtractor {
     );
 
     if (treeSitterResult) {
-      return treeSitterResult;
+      return { ...treeSitterResult, status: "parsed" };
     }
 
-    return this.extractFallback(content);
+    return { ...this.extractFallback(content), status: "degraded" };
   }
 
   private resolveLanguageKey(filePath: string): string {

package/src/core/parser/tree-sitter.ts

@@ -8,6 +8,9 @@ import { PythonExtractor } from "./extractors/python.ts";
 import { TypeScriptExtractor } from "./extractors/typescript.ts";
 
 export class ASTParserEngine {
+  public static isSourceFile(filePath: string): boolean {
+    return /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|php|py|go|rs|java|cs|rb|vue|astro|svelte)$/i.test(filePath);
+  }
   private extractors: CodeExtractor[];
 
   constructor() {
@@ -24,12 +27,14 @@ export class ASTParserEngine {
   public async parseFile(filePath: string, content: string): Promise<ParsedFileAST> {
     for (const extractor of this.extractors) {
       if (extractor.canHandle(filePath)) {
-        return extractor.extract(filePath, content);
+        const result = await extractor.extract(filePath, content);
+        return { status: "parsed", ...result };
       }
     }
 
     // Default fallback extractor for unknown file types
     return {
+      status: "unsupported",
       symbols: [],
       dependencies: [],
     };

package/src/core/parser/wasm-assets.ts

@@ -0,0 +1,17 @@
+import runtime from "web-tree-sitter/tree-sitter.wasm" with { type: "file" };
+import typescript from "tree-sitter-wasms/out/tree-sitter-typescript.wasm" with { type: "file" };
+import tsx from "tree-sitter-wasms/out/tree-sitter-tsx.wasm" with { type: "file" };
+import javascript from "tree-sitter-wasms/out/tree-sitter-javascript.wasm" with { type: "file" };
+import php from "tree-sitter-wasms/out/tree-sitter-php.wasm" with { type: "file" };
+import python from "tree-sitter-wasms/out/tree-sitter-python.wasm" with { type: "file" };
+import go from "tree-sitter-wasms/out/tree-sitter-go.wasm" with { type: "file" };
+
+export const WASM_ASSETS: Record<string, string> = {
+  "tree-sitter.wasm": runtime,
+  "tree-sitter-typescript.wasm": typescript,
+  "tree-sitter-tsx.wasm": tsx,
+  "tree-sitter-javascript.wasm": javascript,
+  "tree-sitter-php.wasm": php,
+  "tree-sitter-python.wasm": python,
+  "tree-sitter-go.wasm": go,
+};

package/src/core/parser/wasm-loader.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import Parser from "web-tree-sitter";
+import { WASM_ASSETS } from "./wasm-assets.ts";
 
 const GRAMMAR_BY_KEY: Record<string, string> = {
   // Extensions
@@ -74,6 +75,8 @@ export function resolveWasmPath(fileName: string, isCoreRuntime: boolean = false
     candidates.push(path.join(envDir, "out", fileName));
   }
 
+  if (WASM_ASSETS[fileName]) candidates.push(WASM_ASSETS[fileName]);
+
   // Tier 2: Walk up from import.meta.dir to package root
   let currentDir = getModuleDir();
   for (let depth = 0; depth < 7; depth++) {

package/src/core/resolver/module-resolver.ts

@@ -97,16 +97,7 @@ export class ModuleResolver {
     filePath: string,
     config: ValidatedSeptumConfig
   ): string | null {
-    const absPath = this.toAbsolutePath(filePath);
-
-    for (const [domainName, domainCfg] of Object.entries(config.domains)) {
-      const domainAbsRoot = this.toAbsolutePath(domainCfg.root);
-      if (this.isSubPathOrSame(absPath, domainAbsRoot)) {
-        return domainName;
-      }
-    }
-
-    return null;
+    return this.matchDomainByPath(filePath, config);
   }
 
   /**

package/src/core/resolver/vertical-slice-tracer.ts

@@ -81,6 +81,7 @@ export class VerticalSliceTracer {
       if (exact) {
         return this.formatSuccessResponse(trimmed, exact, "exact", undefined, effectiveMaxDepth);
       }
+      return { query: trimmed, found: false, max_depth_applied: effectiveMaxDepth, message: `No vertical slice found matching query '${trimmed}'.` };
     }
 
     // 2. URI-only match: "/orders" or "orders/{id}"

package/src/core/session/session-manager.ts

@@ -1,56 +1,72 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { randomUUID } from "node:crypto";
 import type { ActiveFeatureSession } from "../../types/index.ts";
+import { SeptumDatabase } from "../database/client.ts";
 
 export class SessionManager {
   private static readonly SESSION_FILE = ".septum/session.json";
 
-  /**
-   * Save the active feature session to .septum/session.json
-   */
-  public static saveActiveSession(workspaceRoot: string, session: ActiveFeatureSession): void {
-    const septumDir = join(workspaceRoot, ".septum");
-    if (!existsSync(septumDir)) {
-      mkdirSync(septumDir, { recursive: true });
-    }
-    const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    writeFileSync(sessionPath, JSON.stringify(session, null, 2), "utf-8");
+  public static getOwnerId(): string {
+    return process.env.SEPTUM_SESSION_ID || `process:${process.pid}`;
   }
 
-  /**
-   * Get the active feature session, or null if no session exists or file is invalid
-   */
-  public static getActiveSession(workspaceRoot: string): ActiveFeatureSession | null {
-    const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    if (!existsSync(sessionPath)) {
-      return null;
+  private static mutate<T>(workspaceRoot: string, fn: () => T): T {
+    const db = new SeptumDatabase(join(workspaceRoot, ".septum/septum.db"));
+    try {
+      // Serialize ownership checks with writes across CLI and MCP processes.
+      return db.raw.transaction(fn).immediate();
+    } finally {
+      db.close();
     }
+  }
 
-    try {
-      const raw = readFileSync(sessionPath, "utf-8");
-      const parsed = JSON.parse(raw) as ActiveFeatureSession;
-      if (parsed && typeof parsed.feature_key === "string" && Array.isArray(parsed.touchpoints)) {
-        return parsed;
+  public static saveActiveSession(
+    workspaceRoot: string,
+    session: ActiveFeatureSession,
+    ownerId: string = SessionManager.getOwnerId()
+  ): void {
+    SessionManager.mutate(workspaceRoot, () => {
+      const current = SessionManager.getActiveSession(workspaceRoot);
+      if (current && current.owner_id !== ownerId) {
+        throw new Error(`Workspace already has an active feature session owned by '${current.owner_id || "legacy-session"}'. Release it with its owner, or explicitly run 'septum feature clear --force'.`);
       }
-      return null;
-    } catch {
-      return null;
-    }
+      const septumDir = join(workspaceRoot, ".septum");
+      mkdirSync(septumDir, { recursive: true });
+      const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
+      const temporaryPath = `${sessionPath}.${randomUUID()}.tmp`;
+      try {
+        writeFileSync(temporaryPath, JSON.stringify({ ...session, owner_id: ownerId }, null, 2), "utf-8");
+        renameSync(temporaryPath, sessionPath);
+      } finally {
+        rmSync(temporaryPath, { force: true });
+      }
+    });
   }
 
-  /**
-   * Clear the active feature session
-   */
-  public static clearActiveSession(workspaceRoot: string): boolean {
+  public static getActiveSession(workspaceRoot: string): ActiveFeatureSession | null {
     const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    if (existsSync(sessionPath)) {
-      try {
-        rmSync(sessionPath, { force: true });
-        return true;
-      } catch {
-        return false;
+    if (!existsSync(sessionPath)) return null;
+    const parsed = JSON.parse(readFileSync(sessionPath, "utf-8")) as ActiveFeatureSession;
+    if (parsed && typeof parsed.feature_key === "string" && typeof parsed.domain === "string" && Array.isArray(parsed.touchpoints)) return parsed;
+    throw new Error(`Invalid active feature session in '${sessionPath}'. Release it explicitly with 'septum feature clear --force'.`);
+  }
+
+  public static clearActiveSession(
+    workspaceRoot: string,
+    ownerId: string = SessionManager.getOwnerId(),
+    force: boolean = false
+  ): boolean {
+    if (!existsSync(join(workspaceRoot, SessionManager.SESSION_FILE))) return false;
+    return SessionManager.mutate(workspaceRoot, () => {
+      const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
+      if (!existsSync(sessionPath)) return false;
+      if (!force) {
+        const current = SessionManager.getActiveSession(workspaceRoot);
+        if (current?.owner_id !== ownerId) throw new Error("Only the active session owner can release it. Use 'septum feature clear --force' for explicit recovery.");
       }
-    }
-    return false;
+      rmSync(sessionPath);
+      return true;
+    });
   }
 }