septum 0.1.4 → 0.1.5

package/src/core/config/loader.ts

@@ -1,97 +1,97 @@
-import { existsSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
-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";
-import { resolveWorkspaceRoot, isAppHostDirectory } from "../resolver/path-resolver.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,
-    projectRoot?: string
-  ): ValidatedSeptumConfig {
-    const root = resolveWorkspaceRoot(projectRoot);
-    const resolvedDbPath = dbPath
-      ? (isAbsolute(dbPath) ? dbPath : join(root, dbPath))
-      : join(root, ".septum", "septum.db");
-
-    // 1. If database exists and has registered domains, load directly from SQLite SSOT
-    if (existsSync(resolvedDbPath)) {
-      const dbConfig = ConfigLoader.loadFromDatabaseOrDefaults(resolvedDbPath);
-      if (Object.keys(dbConfig.domains).length > 0) {
-        return dbConfig;
-      }
-    }
-
-    // 2. Zero-Config Auto-Discovery: Discover project topology and persist to SQLite
-    // Guard against running auto-discovery inside MCP host / IDE installation folders
-    if (!isAppHostDirectory(root)) {
-      const septumDb = new SeptumDatabase(resolvedDbPath);
-      const repo = new SeptumRepository(septumDb.raw);
-      TopologyDetector.discoverAndPersist(repo, root);
-      septumDb.close();
-    }
-
-    return ConfigLoader.loadFromDatabaseOrDefaults(resolvedDbPath);
-  }
-
-  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 { isAbsolute, join } from "node:path";
+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";
+import { resolveWorkspaceRoot, isAppHostDirectory } from "../resolver/path-resolver.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,
+    projectRoot?: string
+  ): ValidatedSeptumConfig {
+    const root = resolveWorkspaceRoot(projectRoot);
+    const resolvedDbPath = dbPath
+      ? (isAbsolute(dbPath) ? dbPath : join(root, dbPath))
+      : join(root, ".septum", "septum.db");
+
+    // 1. If database exists and has registered domains, load directly from SQLite SSOT
+    if (existsSync(resolvedDbPath)) {
+      const dbConfig = ConfigLoader.loadFromDatabaseOrDefaults(resolvedDbPath);
+      if (Object.keys(dbConfig.domains).length > 0) {
+        return dbConfig;
+      }
+    }
+
+    // 2. Zero-Config Auto-Discovery: Discover project topology and persist to SQLite
+    // Guard against running auto-discovery inside MCP host / IDE installation folders
+    if (!isAppHostDirectory(root)) {
+      const septumDb = new SeptumDatabase(resolvedDbPath);
+      const repo = new SeptumRepository(septumDb.raw);
+      TopologyDetector.discoverAndPersist(repo, root);
+      septumDb.close();
+    }
+
+    return ConfigLoader.loadFromDatabaseOrDefaults(resolvedDbPath);
+  }
+
+  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,44 +1,44 @@
-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)();
-  }
-}
+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)();
+  }
+}