septum 0.1.0 → 0.1.2

package/src/core/config/loader.ts

@@ -1,84 +1,84 @@
-import { existsSync } from "node:fs";
-import { Database } from "bun:sqlite";
-import type { ValidatedSeptumConfig } from "./schema.ts";
-import { TopologyDetector } from "../discovery/topology-detector.ts";
-import { SeptumDatabase } from "../database/client.ts";
-import { SeptumRepository } from "../database/repository.ts";
-
-export class ConfigLoader {
-  /**
-   * Loads configuration with SQLite as the Single Source of Truth (SSOT).
-   * Automatically executes Zero-Config TopologyDetector if the database has no domains.
-   */
-  public static load(dbPath: string = ".septum/septum.db"): ValidatedSeptumConfig {
-    // 1. If database exists and has registered domains, load directly from SQLite SSOT
-    if (existsSync(dbPath)) {
-      const dbConfig = ConfigLoader.loadFromDatabaseOrDefaults(dbPath);
-      if (Object.keys(dbConfig.domains).length > 0) {
-        return dbConfig;
-      }
-    }
-
-    // 2. Zero-Config Auto-Discovery: Discover project topology and persist to SQLite
-    const septumDb = new SeptumDatabase(dbPath);
-    const repo = new SeptumRepository(septumDb.raw);
-    TopologyDetector.discoverAndPersist(repo, process.cwd());
-    septumDb.close();
-
-    return ConfigLoader.loadFromDatabaseOrDefaults(dbPath);
-  }
-
-  public static getDefaultConfig(): ValidatedSeptumConfig {
-    return {
-      version: "1.0",
-      settings: {
-        enforcement: "warn",
-        db_path: ".septum/septum.db",
-        ignore_patterns: [
-          "node_modules/**",
-          "vendor/**",
-          "dist/**",
-          "build/**",
-          "tests/**",
-          ".git/**",
-          ".septum/**",
-        ],
-      },
-      domains: {},
-      features: {},
-    };
-  }
-
-  public static loadFromDatabaseOrDefaults(dbPath: string = ".septum/septum.db"): ValidatedSeptumConfig {
-    const config = ConfigLoader.getDefaultConfig();
-    config.settings.db_path = dbPath;
-
-    if (existsSync(dbPath)) {
-      try {
-        const db = new Database(dbPath, { readonly: true });
-        const tables = db
-          .query<{ name: string }, [string]>(
-            "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"
-          )
-          .get("domains");
-
-        if (tables) {
-          const rows = db.query<any, []>("SELECT * FROM domains").all();
-          for (const r of rows) {
-            config.domains[r.name] = {
-              root: r.root_path,
-              allowed_dependencies: JSON.parse(r.allowed_deps_json || "[]"),
-              forbidden_dependencies: JSON.parse(r.forbidden_deps_json || "[]"),
-              archetypes: JSON.parse(r.archetypes_json || "{}"),
-            };
-          }
-        }
-        db.close();
-      } catch {
-        // Fallback gracefully to default config
-      }
-    }
-
-    return config;
-  }
-}
+import { existsSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import type { ValidatedSeptumConfig } from "./schema.ts";
+import { TopologyDetector } from "../discovery/topology-detector.ts";
+import { SeptumDatabase } from "../database/client.ts";
+import { SeptumRepository } from "../database/repository.ts";
+
+export class ConfigLoader {
+  /**
+   * Loads configuration with SQLite as the Single Source of Truth (SSOT).
+   * Automatically executes Zero-Config TopologyDetector if the database has no domains.
+   */
+  public static load(dbPath: string = ".septum/septum.db"): ValidatedSeptumConfig {
+    // 1. If database exists and has registered domains, load directly from SQLite SSOT
+    if (existsSync(dbPath)) {
+      const dbConfig = ConfigLoader.loadFromDatabaseOrDefaults(dbPath);
+      if (Object.keys(dbConfig.domains).length > 0) {
+        return dbConfig;
+      }
+    }
+
+    // 2. Zero-Config Auto-Discovery: Discover project topology and persist to SQLite
+    const septumDb = new SeptumDatabase(dbPath);
+    const repo = new SeptumRepository(septumDb.raw);
+    TopologyDetector.discoverAndPersist(repo, process.cwd());
+    septumDb.close();
+
+    return ConfigLoader.loadFromDatabaseOrDefaults(dbPath);
+  }
+
+  public static getDefaultConfig(): ValidatedSeptumConfig {
+    return {
+      version: "1.0",
+      settings: {
+        enforcement: "warn",
+        db_path: ".septum/septum.db",
+        ignore_patterns: [
+          "node_modules/**",
+          "vendor/**",
+          "dist/**",
+          "build/**",
+          "tests/**",
+          ".git/**",
+          ".septum/**",
+        ],
+      },
+      domains: {},
+      features: {},
+    };
+  }
+
+  public static loadFromDatabaseOrDefaults(dbPath: string = ".septum/septum.db"): ValidatedSeptumConfig {
+    const config = ConfigLoader.getDefaultConfig();
+    config.settings.db_path = dbPath;
+
+    if (existsSync(dbPath)) {
+      try {
+        const db = new Database(dbPath, { readonly: true });
+        const tables = db
+          .query<{ name: string }, [string]>(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"
+          )
+          .get("domains");
+
+        if (tables) {
+          const rows = db.query<any, []>("SELECT * FROM domains").all();
+          for (const r of rows) {
+            config.domains[r.name] = {
+              root: r.root_path,
+              allowed_dependencies: JSON.parse(r.allowed_deps_json || "[]"),
+              forbidden_dependencies: JSON.parse(r.forbidden_deps_json || "[]"),
+              archetypes: JSON.parse(r.archetypes_json || "{}"),
+            };
+          }
+        }
+        db.close();
+      } catch {
+        // Fallback gracefully to default config
+      }
+    }
+
+    return config;
+  }
+}

package/src/core/config/schema.ts

@@ -1,39 +1,39 @@
-import { z } from "zod";
-
-export const DomainConfigSchema = z.object({
-  root: z.string().min(1, "root path cannot be empty"),
-  description: z.string().optional(),
-  allowed_dependencies: z.array(z.string()).default([]),
-  forbidden_dependencies: z.array(z.string()).default([]),
-  archetypes: z.record(z.string()).optional().default({}),
-});
-
-export const FeatureConfigSchema = z.object({
-  domain: z.string().min(1, "domain reference is required"),
-  description: z.string().optional(),
-  allowed_touchpoints: z.array(z.string()).min(1, "allowed_touchpoints must contain at least one file/path"),
-  reuse_symbols: z.array(z.string()).optional().default([]),
-  input_contract: z.record(z.unknown()).optional().default({}),
-  output_contract: z.record(z.unknown()).optional().default({}),
-});
-
-export const SeptumConfigSchema = z.object({
-  version: z.string().default("1.0"),
-  settings: z
-    .object({
-      enforcement: z.enum(["strict", "warn"]).default("strict"),
-      db_path: z.string().default(".septum/septum.db"),
-      ignore_patterns: z
-        .array(z.string())
-        .default(["node_modules/**", "vendor/**", "dist/**", "build/**", "tests/**", ".git/**"]),
-    })
-    .default({
-      enforcement: "strict",
-      db_path: ".septum/septum.db",
-      ignore_patterns: ["node_modules/**", "vendor/**", "dist/**", "build/**", "tests/**", ".git/**"],
-    }),
-  domains: z.record(DomainConfigSchema).default({}),
-  features: z.record(FeatureConfigSchema).optional().default({}),
-});
-
-export type ValidatedSeptumConfig = z.infer<typeof SeptumConfigSchema>;
+import { z } from "zod";
+
+export const DomainConfigSchema = z.object({
+  root: z.string().min(1, "root path cannot be empty"),
+  description: z.string().optional(),
+  allowed_dependencies: z.array(z.string()).default([]),
+  forbidden_dependencies: z.array(z.string()).default([]),
+  archetypes: z.record(z.string()).optional().default({}),
+});
+
+export const FeatureConfigSchema = z.object({
+  domain: z.string().min(1, "domain reference is required"),
+  description: z.string().optional(),
+  allowed_touchpoints: z.array(z.string()).min(1, "allowed_touchpoints must contain at least one file/path"),
+  reuse_symbols: z.array(z.string()).optional().default([]),
+  input_contract: z.record(z.unknown()).optional().default({}),
+  output_contract: z.record(z.unknown()).optional().default({}),
+});
+
+export const SeptumConfigSchema = z.object({
+  version: z.string().default("1.0"),
+  settings: z
+    .object({
+      enforcement: z.enum(["strict", "warn"]).default("strict"),
+      db_path: z.string().default(".septum/septum.db"),
+      ignore_patterns: z
+        .array(z.string())
+        .default(["node_modules/**", "vendor/**", "dist/**", "build/**", "tests/**", ".git/**"]),
+    })
+    .default({
+      enforcement: "strict",
+      db_path: ".septum/septum.db",
+      ignore_patterns: ["node_modules/**", "vendor/**", "dist/**", "build/**", "tests/**", ".git/**"],
+    }),
+  domains: z.record(DomainConfigSchema).default({}),
+  features: z.record(FeatureConfigSchema).optional().default({}),
+});
+
+export type ValidatedSeptumConfig = z.infer<typeof SeptumConfigSchema>;

package/src/core/database/client.ts

@@ -1,132 +1,44 @@
-import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-export class SeptumDatabase {
-  private db: Database;
-  private dbPath: string;
-
-  constructor(dbPath: string = ".septum/septum.db") {
-    this.dbPath = dbPath;
-    const dir = dirname(dbPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-
-    this.db = new Database(dbPath, { create: true });
-    this.configurePragmas();
-    this.initSchema();
-  }
-
-  private configurePragmas(): void {
-    this.db.run("PRAGMA journal_mode = WAL;");
-    this.db.run("PRAGMA foreign_keys = ON;");
-    this.db.run("PRAGMA synchronous = NORMAL;");
-  }
-
-  private initSchema(): void {
-    const schemaFile = join(import.meta.dir, "schema.sql");
-    if (existsSync(schemaFile)) {
-      const sql = readFileSync(schemaFile, "utf-8");
-      this.db.run(sql);
-    } else {
-      // Fallback inline schema if schema.sql is not found in compiled bundle
-      this.db.run(`
-        CREATE TABLE IF NOT EXISTS domains (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          name TEXT NOT NULL UNIQUE,
-          root_path TEXT NOT NULL,
-          allowed_deps_json TEXT NOT NULL DEFAULT '[]',
-          forbidden_deps_json TEXT NOT NULL DEFAULT '[]',
-          archetypes_json TEXT NOT NULL DEFAULT '{}',
-          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-          updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-        );
-        CREATE TABLE IF NOT EXISTS files (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          domain_id INTEGER NOT NULL,
-          path TEXT NOT NULL UNIQUE,
-          archetype TEXT NOT NULL DEFAULT 'unknown',
-          content_hash TEXT NOT NULL,
-          line_count INTEGER NOT NULL DEFAULT 0,
-          last_scanned_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-          FOREIGN KEY (domain_id) REFERENCES domains(id) ON DELETE CASCADE
-        );
-        CREATE TABLE IF NOT EXISTS symbols (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          file_id INTEGER NOT NULL,
-          name TEXT NOT NULL,
-          kind TEXT NOT NULL,
-          signature TEXT NOT NULL,
-          visibility TEXT NOT NULL DEFAULT 'public',
-          line_start INTEGER NOT NULL DEFAULT 0,
-          line_end INTEGER NOT NULL DEFAULT 0,
-          FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
-        );
-        CREATE TABLE IF NOT EXISTS dependencies (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          source_file_id INTEGER NOT NULL,
-          target_symbol_or_path TEXT NOT NULL,
-          import_statement TEXT NOT NULL,
-          line_number INTEGER NOT NULL DEFAULT 0,
-          is_external BOOLEAN NOT NULL DEFAULT 0,
-          FOREIGN KEY (source_file_id) REFERENCES files(id) ON DELETE CASCADE
-        );
-        CREATE TABLE IF NOT EXISTS vertical_slices (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          domain_id INTEGER,
-          feature_key TEXT,
-          http_method TEXT NOT NULL,
-          route_uri TEXT NOT NULL,
-          route_name TEXT,
-          controller_class TEXT NOT NULL,
-          action_name TEXT NOT NULL,
-          controller_file TEXT,
-          controller_line INTEGER DEFAULT 0,
-          architecture_style TEXT NOT NULL DEFAULT 'clean',
-          entry_kind TEXT NOT NULL DEFAULT 'http_route',
-          execution_chain_json TEXT NOT NULL,
-          created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-          FOREIGN KEY (domain_id) REFERENCES domains(id) ON DELETE CASCADE
-        );
-        CREATE INDEX IF NOT EXISTS idx_slices_route_uri ON vertical_slices(route_uri);
-        CREATE INDEX IF NOT EXISTS idx_slices_route_name ON vertical_slices(route_name);
-        CREATE INDEX IF NOT EXISTS idx_slices_controller ON vertical_slices(controller_class, action_name);
-        CREATE TABLE IF NOT EXISTS repo_meta (
-          key TEXT PRIMARY KEY,
-          value TEXT NOT NULL,
-          updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-        );
-      `);
-    }
-    this.migrateSchema();
-  }
-
-  private migrateSchema(): void {
-    try {
-      const tableInfo = this.db.query<{ name: string }, []>("PRAGMA table_info(vertical_slices)").all();
-      const existingCols = new Set(tableInfo.map((c) => c.name));
-
-      if (tableInfo.length > 0) {
-        if (existingCols.has("form_request_class") || !existingCols.has("execution_chain_json")) {
-          this.db.run("DROP TABLE IF EXISTS vertical_slices;");
-          this.initSchema();
-        }
-      }
-    } catch (_) {
-      // Ignore migration errors
-    }
-  }
-
-  public get raw(): Database {
-    return this.db;
-  }
-
-  public close(): void {
-    this.db.close();
-  }
-
-  public transaction<T>(fn: () => T): T {
-    return this.db.transaction(fn)();
-  }
-}
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { initializeDatabaseSchema } from "./schema.ts";
+
+export class SeptumDatabase {
+  private db: Database;
+  private dbPath: string;
+
+  constructor(dbPath: string = ".septum/septum.db") {
+    this.dbPath = dbPath;
+    const dir = dirname(dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    this.db = new Database(dbPath, { create: true });
+    this.configurePragmas();
+    this.initSchema();
+  }
+
+  private configurePragmas(): void {
+    this.db.run("PRAGMA journal_mode = WAL;");
+    this.db.run("PRAGMA busy_timeout = 5000;");
+    this.db.run("PRAGMA foreign_keys = ON;");
+    this.db.run("PRAGMA synchronous = NORMAL;");
+  }
+
+  private initSchema(): void {
+    initializeDatabaseSchema(this.db);
+  }
+
+  public get raw(): Database {
+    return this.db;
+  }
+
+  public close(): void {
+    this.db.close();
+  }
+
+  public transaction<T>(fn: () => T): T {
+    return this.db.transaction(fn)();
+  }
+}