septum 0.1.0

package/src/core/database/repositories/dependency.repository.ts

@@ -0,0 +1,279 @@
+import * as fs from "node:fs";
+import type { Database } from "bun:sqlite";
+import type {
+  ExtractedDependency,
+  GetSymbolImpactResponse,
+  InboundCaller,
+  VerticalSliceRecord,
+} from "../../../types/index.ts";
+
+export class DependencyRepository {
+  constructor(private db: Database) {}
+
+  public replaceFileDependencies(fileId: number, deps: ExtractedDependency[]): void {
+    this.db.query("DELETE FROM dependencies WHERE source_file_id = ?").run(fileId);
+    if (deps.length === 0) return;
+
+    const stmt = this.db.query(
+      `INSERT INTO dependencies (source_file_id, target_symbol_or_path, import_statement, line_number, is_external) 
+       VALUES (?, ?, ?, ?, ?)`
+    );
+
+    for (const dep of deps) {
+      stmt.run(fileId, dep.target, dep.statement, dep.line_number, dep.is_external ? 1 : 0);
+    }
+  }
+
+  public upsertVerticalSlice(
+    slice: Omit<VerticalSliceRecord, "id" | "created_at">
+  ): void {
+    const existing = this.db
+      .query<VerticalSliceRecord, [string, string]>(
+        "SELECT id FROM vertical_slices WHERE http_method = ? AND route_uri = ?"
+      )
+      .get(slice.http_method, slice.route_uri);
+
+    if (existing) {
+      this.db
+        .query(
+          `UPDATE vertical_slices
+           SET domain_id = ?, feature_key = ?, route_name = ?, controller_class = ?,
+               action_name = ?, controller_file = ?, controller_line = ?,
+               architecture_style = ?, entry_kind = ?, execution_chain_json = ?
+           WHERE id = ?`
+        )
+        .run(
+          slice.domain_id,
+          slice.feature_key,
+          slice.route_name,
+          slice.controller_class,
+          slice.action_name,
+          slice.controller_file,
+          slice.controller_line,
+          slice.architecture_style ?? "clean",
+          slice.entry_kind ?? "http_route",
+          slice.execution_chain_json,
+          existing.id
+        );
+    } else {
+      this.db
+        .query(
+          `INSERT INTO vertical_slices (
+            domain_id, feature_key, http_method, route_uri, route_name,
+            controller_class, action_name, controller_file, controller_line,
+            architecture_style, entry_kind, execution_chain_json
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(
+          slice.domain_id,
+          slice.feature_key,
+          slice.http_method,
+          slice.route_uri,
+          slice.route_name,
+          slice.controller_class,
+          slice.action_name,
+          slice.controller_file,
+          slice.controller_line,
+          slice.architecture_style ?? "clean",
+          slice.entry_kind ?? "http_route",
+          slice.execution_chain_json
+        );
+    }
+  }
+
+  public findVerticalSlices(searchTerm: string): VerticalSliceRecord[] {
+    const term = searchTerm.trim();
+    const wild = `%${term}%`;
+    const query = `
+      SELECT * FROM vertical_slices
+      WHERE route_uri LIKE ?
+         OR route_name LIKE ?
+         OR controller_class LIKE ?
+         OR action_name LIKE ?
+         OR feature_key LIKE ?
+         OR execution_chain_json LIKE ?
+      ORDER BY id ASC
+    `;
+    return this.db.query<VerticalSliceRecord, [string, string, string, string, string, string]>(query).all(
+      wild, wild, wild, wild, wild, wild
+    );
+  }
+
+  public getAllVerticalSlices(): VerticalSliceRecord[] {
+    return this.db.query<VerticalSliceRecord, []>("SELECT * FROM vertical_slices ORDER BY id ASC").all();
+  }
+
+  public clearVerticalSlices(domainId?: number): void {
+    if (domainId) {
+      this.db.query("DELETE FROM vertical_slices WHERE domain_id = ?").run(domainId);
+    } else {
+      this.db.query("DELETE FROM vertical_slices").run();
+    }
+  }
+
+  public getAllDependenciesWithDomains(): Array<{
+    source_file: string;
+    source_domain: string;
+    line_number: number;
+    target: string;
+    statement: string;
+    is_external: boolean;
+  }> {
+    const query = `
+      SELECT 
+        f.path AS source_file,
+        d.name AS source_domain,
+        dep.line_number,
+        dep.target_symbol_or_path AS target,
+        dep.import_statement AS statement,
+        dep.is_external
+      FROM dependencies dep
+      JOIN files f ON dep.source_file_id = f.id
+      JOIN domains d ON f.domain_id = d.id
+      ORDER BY d.name, f.path, dep.line_number
+    `;
+    return this.db.query<any, []>(query).all();
+  }
+
+  public getSymbolImpact(symbolQuery: string): GetSymbolImpactResponse {
+    const trimmed = symbolQuery.trim();
+    if (!trimmed) {
+      return {
+        target_symbol: symbolQuery,
+        impact_summary: {
+          total_dependents: 0,
+          risk_level: "low",
+          affected_files_count: 0,
+        },
+        inbound_callers: [],
+      };
+    }
+
+    let targetContainer = trimmed;
+    let targetMethod = "";
+    if (trimmed.includes("::")) {
+      const parts = trimmed.split("::");
+      targetContainer = parts[0];
+      targetMethod = parts[1];
+    } else if (trimmed.includes("@")) {
+      const parts = trimmed.split("@");
+      targetContainer = parts[0];
+      targetMethod = parts[1];
+    }
+
+    // 1. Inbound dependencies from dependencies table
+    const depSql = `
+      SELECT 
+        f.path AS file,
+        d.line_number,
+        d.target_symbol_or_path,
+        dom.name AS domain_name
+      FROM dependencies d
+      JOIN files f ON d.source_file_id = f.id
+      JOIN domains dom ON f.domain_id = dom.id
+      WHERE d.target_symbol_or_path LIKE ?
+         OR d.target_symbol_or_path LIKE ?
+      ORDER BY f.path ASC, d.line_number ASC
+    `;
+    const depRows = this.db
+      .query<any, [string, string]>(depSql)
+      .all(`%${targetContainer}%`, `%${trimmed}%`);
+
+    const callersMap = new Map<string, InboundCaller>();
+
+    for (const row of depRows) {
+      // Find enclosing symbol in caller file if any
+      const enclosing = this.db
+        .query<{ name: string; kind: string }, [string, number]>(
+          `SELECT s.name, s.kind 
+           FROM symbols s
+           JOIN files f ON s.file_id = f.id
+           WHERE f.path = ? AND ? BETWEEN s.line_start AND s.line_end
+           ORDER BY (s.line_end - s.line_start) ASC LIMIT 1`
+        )
+        .get(row.file, row.line_number);
+
+      const callerName = enclosing ? enclosing.name : `${row.file}:${row.line_number}`;
+      const key = `${row.file}:${row.line_number}:${callerName}`;
+
+      if (!callersMap.has(key)) {
+        callersMap.set(key, {
+          file: row.file,
+          caller: callerName,
+          line: row.line_number,
+          kind: enclosing?.kind || "import",
+          domain: row.domain_name,
+        });
+      }
+    }
+
+    // 2. Scan file content of callers or related files for exact method calls if targetMethod specified
+    if (targetMethod) {
+      // Look for files importing targetContainer and inspect if they call targetMethod
+      const uniqueFiles = Array.from(new Set(depRows.map((r) => r.file)));
+      for (const filePath of uniqueFiles) {
+        try {
+          if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lines = content.split(/\r?\n/);
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i];
+              if (
+                line.includes(`->${targetMethod}(`) ||
+                line.includes(`::${targetMethod}(`)
+              ) {
+                const lineNum = i + 1;
+                const enclosing = this.db
+                  .query<{ name: string; kind: string }, [string, number]>(
+                    `SELECT s.name, s.kind 
+                     FROM symbols s
+                     JOIN files f ON s.file_id = f.id
+                     WHERE f.path = ? AND ? BETWEEN s.line_start AND s.line_end
+                     ORDER BY (s.line_end - s.line_start) ASC LIMIT 1`
+                  )
+                  .get(filePath, lineNum);
+
+                const callerName = enclosing ? enclosing.name : `${filePath}:${lineNum}`;
+                const key = `${filePath}:${lineNum}:${callerName}`;
+                if (!callersMap.has(key)) {
+                  callersMap.set(key, {
+                    file: filePath,
+                    caller: callerName,
+                    line: lineNum,
+                    kind: enclosing?.kind || "call",
+                  });
+                }
+              }
+            }
+          }
+        } catch {
+          // Ignore read errors
+        }
+      }
+    }
+
+    const inboundCallers = Array.from(callersMap.values());
+    const affectedFiles = new Set(inboundCallers.map((c) => c.file));
+    const distinctDomains = new Set(
+      inboundCallers.map((c) => c.domain).filter(Boolean)
+    );
+
+    let riskLevel: "low" | "medium" | "high" = "low";
+    if (affectedFiles.size > 5 || distinctDomains.size > 2) {
+      riskLevel = "high";
+    } else if (affectedFiles.size >= 2 || distinctDomains.size >= 2) {
+      riskLevel = "medium";
+    }
+
+    return {
+      target_symbol: trimmed,
+      impact_summary: {
+        total_dependents: inboundCallers.length,
+        risk_level: riskLevel,
+        affected_files_count: affectedFiles.size,
+      },
+      inbound_callers: inboundCallers,
+    };
+  }
+
+}

package/src/core/database/repositories/domain.repository.ts

@@ -0,0 +1,198 @@
+import type { Database } from "bun:sqlite";
+import type {
+  DomainCatalogResponse,
+  DomainConfig,
+  DomainRecord,
+  FileRecord,
+  SymbolKind,
+  SymbolRecord,
+} from "../../../types/index.ts";
+
+export class DomainRepository {
+  constructor(private db: Database) {}
+
+  public upsertDomain(name: string, config: DomainConfig): number {
+    const normalizedName = name.trim();
+    const existing = this.getDomainByName(normalizedName);
+
+    // Merge dependencies and archetypes if existing and incoming is empty
+    let allowed = config.allowed_dependencies ?? [];
+    let forbidden = config.forbidden_dependencies ?? [];
+    let archetypes = config.archetypes ?? {};
+
+    if (existing) {
+      if (allowed.length === 0 && existing.allowed_deps_json && existing.allowed_deps_json !== "[]") {
+        try {
+          allowed = JSON.parse(existing.allowed_deps_json);
+        } catch {}
+      }
+      if (forbidden.length === 0 && existing.forbidden_deps_json && existing.forbidden_deps_json !== "[]") {
+        try {
+          forbidden = JSON.parse(existing.forbidden_deps_json);
+        } catch {}
+      }
+      if (Object.keys(archetypes).length === 0 && existing.archetypes_json && existing.archetypes_json !== "{}") {
+        try {
+          archetypes = JSON.parse(existing.archetypes_json);
+        } catch {}
+      }
+    }
+
+    const allowedJson = JSON.stringify(allowed);
+    const forbiddenJson = JSON.stringify(forbidden);
+    const archetypesJson = JSON.stringify(archetypes);
+
+    const query = `
+      INSERT INTO domains (name, root_path, allowed_deps_json, forbidden_deps_json, archetypes_json)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(name) DO UPDATE SET
+        root_path = excluded.root_path,
+        allowed_deps_json = excluded.allowed_deps_json,
+        forbidden_deps_json = excluded.forbidden_deps_json,
+        archetypes_json = excluded.archetypes_json,
+        updated_at = CURRENT_TIMESTAMP
+    `;
+    this.db.query(query).run(normalizedName, config.root, allowedJson, forbiddenJson, archetypesJson);
+
+    const record = this.getDomainByName(normalizedName);
+    return record?.id ?? 0;
+  }
+
+  public getDomainByName(name: string): DomainRecord | null {
+    return this.db
+      .query<DomainRecord, [string]>("SELECT * FROM domains WHERE LOWER(name) = LOWER(?)")
+      .get(name.trim());
+  }
+
+  public getAllDomains(): DomainRecord[] {
+    return this.db.query<DomainRecord, []>("SELECT * FROM domains ORDER BY name ASC").all();
+  }
+
+  public getDomainCatalog(
+    domainName: string,
+    archetypeFilter?: string
+  ): DomainCatalogResponse | null {
+    const domain = this.getDomainByName(domainName);
+    if (!domain) return null;
+
+    const allowedDeps: string[] = JSON.parse(domain.allowed_deps_json || "[]");
+    const forbiddenDeps: string[] = JSON.parse(domain.forbidden_deps_json || "[]");
+
+    let filesQuery = "SELECT * FROM files WHERE domain_id = ?";
+    const params: [number, string?] = [domain.id];
+
+    if (archetypeFilter) {
+      filesQuery += " AND archetype = ?";
+      params.push(archetypeFilter);
+    }
+    filesQuery += " ORDER BY path ASC";
+
+    const files = this.db.query<FileRecord, any>(filesQuery).all(...params);
+
+    const catalogFiles: DomainCatalogResponse["files"] = [];
+
+    for (const file of files) {
+      const symbols = this.db
+        .query<SymbolRecord, [number]>(
+          "SELECT * FROM symbols WHERE file_id = ? ORDER BY line_start ASC"
+        )
+        .all(file.id);
+
+      const symbolMap = new Map<
+        string,
+        {
+          name: string;
+          kind: SymbolKind;
+          properties: string[];
+          methods: string[];
+          signatures: string[];
+        }
+      >();
+
+      for (const sym of symbols) {
+        if (
+          sym.kind === "class" ||
+          sym.kind === "interface" ||
+          sym.kind === "trait" ||
+          sym.kind === "enum"
+        ) {
+          if (!symbolMap.has(sym.name)) {
+            symbolMap.set(sym.name, {
+              name: sym.name,
+              kind: sym.kind,
+              properties: [],
+              methods: [],
+              signatures: [sym.signature],
+            });
+          }
+        } else if (sym.kind === "method") {
+          let targetContainer = Array.from(symbolMap.values()).pop();
+          if (sym.name.includes("::")) {
+            const containerName = sym.name.split("::")[0];
+            if (symbolMap.has(containerName)) {
+              targetContainer = symbolMap.get(containerName);
+            }
+          }
+          if (targetContainer) {
+            targetContainer.methods.push(sym.signature);
+          } else {
+            symbolMap.set(sym.name, {
+              name: sym.name,
+              kind: sym.kind,
+              properties: [],
+              methods: [],
+              signatures: [sym.signature],
+            });
+          }
+        } else if (sym.kind === "property") {
+          let targetContainer = Array.from(symbolMap.values()).pop();
+          if (sym.name.includes("::")) {
+            const containerName = sym.name.split("::")[0];
+            if (symbolMap.has(containerName)) {
+              targetContainer = symbolMap.get(containerName);
+            }
+          }
+          if (targetContainer) {
+            targetContainer.properties.push(sym.signature);
+          } else {
+            symbolMap.set(sym.name, {
+              name: sym.name,
+              kind: sym.kind,
+              properties: [sym.signature],
+              methods: [],
+              signatures: [sym.signature],
+            });
+          }
+        } else {
+          symbolMap.set(sym.name, {
+            name: sym.name,
+            kind: sym.kind,
+            properties: [],
+            methods: [],
+            signatures: [sym.signature],
+          });
+        }
+      }
+
+      catalogFiles.push({
+        path: file.path,
+        archetype: file.archetype,
+        symbols: Array.from(symbolMap.values()).map((s) => ({
+          name: s.name,
+          kind: s.kind,
+          properties: s.properties.length > 0 ? s.properties : undefined,
+          methods: s.methods.length > 0 ? s.methods : undefined,
+          signatures: s.signatures.length > 0 ? s.signatures : undefined,
+        })),
+      });
+    }
+
+    return {
+      domain: domain.name,
+      root: domain.root_path,
+      allowed_dependencies: allowedDeps,
+      forbidden_dependencies: forbiddenDeps,
+      files: catalogFiles,
+    };
+  }
+}

package/src/core/database/repositories/file.repository.ts

@@ -0,0 +1,99 @@
+import type { Database } from "bun:sqlite";
+import type { ArchetypeKind, DomainRecord, FileRecord } from "../../../types/index.ts";
+
+export class FileRepository {
+  constructor(private db: Database) {}
+
+  public getFileByPath(path: string): FileRecord | null {
+    return this.db
+      .query<FileRecord, [string]>("SELECT * FROM files WHERE path = ?")
+      .get(path);
+  }
+
+  public getFileById(id: number): FileRecord | null {
+    return this.db
+      .query<FileRecord, [number]>("SELECT * FROM files WHERE id = ?")
+      .get(id);
+  }
+
+  public getFilesByDomain(domainId: number): FileRecord[] {
+    return this.db
+      .query<FileRecord, [number]>("SELECT * FROM files WHERE domain_id = ? ORDER BY path ASC")
+      .all(domainId);
+  }
+
+  public upsertFile(
+    domainId: number,
+    path: string,
+    archetype: ArchetypeKind,
+    contentHash: string,
+    lineCount: number,
+    mtimeMs: number = 0,
+    sizeBytes: number = 0
+  ): number {
+    const existing = this.getFileByPath(path);
+    if (existing) {
+      this.db
+        .query(
+          `UPDATE files 
+           SET domain_id = ?, archetype = ?, content_hash = ?, line_count = ?, mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
+           WHERE id = ?`
+        )
+        .run(domainId, archetype, contentHash, lineCount, mtimeMs, sizeBytes, existing.id);
+      return existing.id;
+    } else {
+      const result = this.db
+        .query(
+          `INSERT INTO files (domain_id, path, archetype, content_hash, line_count, mtime_ms, size_bytes) 
+           VALUES (?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(domainId, path, archetype, contentHash, lineCount, mtimeMs, sizeBytes);
+      return Number(result.lastInsertRowid);
+    }
+  }
+
+  public updateFileMetadataOnly(id: number, mtimeMs: number, sizeBytes: number): void {
+    this.db
+      .query(
+        `UPDATE files 
+         SET mtime_ms = ?, size_bytes = ?, last_scanned_at = CURRENT_TIMESTAMP 
+         WHERE id = ?`
+      )
+      .run(mtimeMs, sizeBytes, id);
+  }
+
+  public deleteFilesNotInPaths(domainId: number, validPaths: string[]): number {
+    if (validPaths.length === 0) {
+      const res = this.db.query("DELETE FROM files WHERE domain_id = ?").run(domainId);
+      return Number(res.changes);
+    }
+    const existingFiles = this.getFilesByDomain(domainId);
+    const validSet = new Set(validPaths);
+    let deletedCount = 0;
+    for (const f of existingFiles) {
+      if (!validSet.has(f.path)) {
+        this.db.query("DELETE FROM files WHERE id = ?").run(f.id);
+        deletedCount++;
+      }
+    }
+    return deletedCount;
+  }
+
+  public deleteFile(path: string): void {
+    this.db.query("DELETE FROM files WHERE path = ?").run(path);
+  }
+
+  public getFileWithDomain(
+    filePath: string
+  ): { file: FileRecord; domain: DomainRecord } | null {
+    const file = this.getFileByPath(filePath);
+    if (!file) return null;
+
+    const domain = this.db
+      .query<DomainRecord, [number]>("SELECT * FROM domains WHERE id = ?")
+      .get(file.domain_id);
+    if (!domain) return null;
+
+    return { file, domain };
+  }
+}

package/src/core/database/repositories/meta.repository.ts

@@ -0,0 +1,33 @@
+import type { Database } from "bun:sqlite";
+
+export class MetaRepository {
+  constructor(private db: Database) {}
+
+  public getMeta(key: string): string | null {
+    const row = this.db
+      .query<{ value: string }, [string]>("SELECT value FROM repo_meta WHERE key = ?")
+      .get(key);
+    return row ? row.value : null;
+  }
+
+  public setMeta(key: string, value: string): void {
+    this.db
+      .query(
+        `INSERT INTO repo_meta (key, value, updated_at) 
+         VALUES (?, ?, CURRENT_TIMESTAMP)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = CURRENT_TIMESTAMP`
+      )
+      .run(key, value);
+  }
+
+  public getAllMeta(): Record<string, string> {
+    const rows = this.db
+      .query<{ key: string; value: string }, []>("SELECT key, value FROM repo_meta")
+      .all();
+    const result: Record<string, string> = {};
+    for (const r of rows) {
+      result[r.key] = r.value;
+    }
+    return result;
+  }
+}