septum 0.1.4 → 0.1.6

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

@@ -1,56 +1,56 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { ActiveFeatureSession } from "../../types/index.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");
-  }
-
-  /**
-   * 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;
-    }
-
-    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;
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Clear the active feature session
-   */
-  public static clearActiveSession(workspaceRoot: string): boolean {
-    const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
-    if (existsSync(sessionPath)) {
-      try {
-        rmSync(sessionPath, { force: true });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  }
-}
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ActiveFeatureSession } from "../../types/index.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");
+  }
+
+  /**
+   * 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;
+    }
+
+    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;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Clear the active feature session
+   */
+  public static clearActiveSession(workspaceRoot: string): boolean {
+    const sessionPath = join(workspaceRoot, SessionManager.SESSION_FILE);
+    if (existsSync(sessionPath)) {
+      try {
+        rmSync(sessionPath, { force: true });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+}

package/src/core/telemetry/telemetry.ts

@@ -1,86 +1,86 @@
-import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-export interface SeptumToolCallEvent {
-  timestamp?: string;
-  event: "tool_call_completed" | "tool_call_failed";
-  tool: string;
-  duration_ms: number;
-  input: Record<string, any>;
-  metrics?: {
-    bytes_out?: number;
-    lines_out?: number;
-    nodes_returned?: number;
-  };
-  session?: {
-    feature_key?: string | null;
-    domain?: string | null;
-  } | null;
-  status: "success" | "error";
-  error?: {
-    code?: string;
-    message: string;
-    stack?: string;
-  };
-}
-
-export class SeptumTelemetry {
-  private static readonly MAX_LOG_SIZE_BYTES = 2 * 1024 * 1024; // 2MB
-  private static readonly SLOW_EXECUTION_THRESHOLD_MS = 250;
-
-  /**
-   * Resolves the log file path inside the active workspace's .septum directory.
-   */
-  public static getLogPath(workspaceRoot: string = process.cwd()): string {
-    return join(workspaceRoot, ".septum", "septum.log");
-  }
-
-  /**
-   * Records a tool call event to both stderr (dual-sink) and .septum/septum.log.
-   */
-  public static recordToolCall(
-    event: SeptumToolCallEvent,
-    workspaceRoot: string = process.cwd()
-  ): void {
-    const payload: SeptumToolCallEvent = {
-      timestamp: event.timestamp || new Date().toISOString(),
-      ...event,
-    };
-
-    const jsonLine = JSON.stringify(payload);
-
-    // Sink 1: Live stderr stream for operator monitoring (slow queries & failures)
-    if (payload.status === "error") {
-      console.error(`[Septum Telemetry ERROR] ${jsonLine}`);
-    } else if (payload.duration_ms >= this.SLOW_EXECUTION_THRESHOLD_MS) {
-      console.error(`[Septum Telemetry SLOW_WARN] ${jsonLine}`);
-    }
-
-    // Sink 2: Append-only persistent file recorder in .septum/septum.log
-    try {
-      const logPath = this.getLogPath(workspaceRoot);
-      const logDir = dirname(logPath);
-
-      if (!existsSync(logDir)) {
-        mkdirSync(logDir, { recursive: true });
-      }
-
-      // Check for rotation if file exceeds 2MB
-      if (existsSync(logPath)) {
-        try {
-          const stats = statSync(logPath);
-          if (stats.size >= this.MAX_LOG_SIZE_BYTES) {
-            const rotatedPath = `${logPath}.1`;
-            renameSync(logPath, rotatedPath);
-          }
-        } catch {
-          // If stat/rotation fails, proceed to append without crashing
-        }
-      }
-
-      appendFileSync(logPath, `${jsonLine}\n`, "utf8");
-    } catch {
-      // Telemetry file writes must never crash the main application process
-    }
-  }
-}
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export interface SeptumToolCallEvent {
+  timestamp?: string;
+  event: "tool_call_completed" | "tool_call_failed";
+  tool: string;
+  duration_ms: number;
+  input: Record<string, any>;
+  metrics?: {
+    bytes_out?: number;
+    lines_out?: number;
+    nodes_returned?: number;
+  };
+  session?: {
+    feature_key?: string | null;
+    domain?: string | null;
+  } | null;
+  status: "success" | "error";
+  error?: {
+    code?: string;
+    message: string;
+    stack?: string;
+  };
+}
+
+export class SeptumTelemetry {
+  private static readonly MAX_LOG_SIZE_BYTES = 2 * 1024 * 1024; // 2MB
+  private static readonly SLOW_EXECUTION_THRESHOLD_MS = 250;
+
+  /**
+   * Resolves the log file path inside the active workspace's .septum directory.
+   */
+  public static getLogPath(workspaceRoot: string = process.cwd()): string {
+    return join(workspaceRoot, ".septum", "septum.log");
+  }
+
+  /**
+   * Records a tool call event to both stderr (dual-sink) and .septum/septum.log.
+   */
+  public static recordToolCall(
+    event: SeptumToolCallEvent,
+    workspaceRoot: string = process.cwd()
+  ): void {
+    const payload: SeptumToolCallEvent = {
+      timestamp: event.timestamp || new Date().toISOString(),
+      ...event,
+    };
+
+    const jsonLine = JSON.stringify(payload);
+
+    // Sink 1: Live stderr stream for operator monitoring (slow queries & failures)
+    if (payload.status === "error") {
+      console.error(`[Septum Telemetry ERROR] ${jsonLine}`);
+    } else if (payload.duration_ms >= this.SLOW_EXECUTION_THRESHOLD_MS) {
+      console.error(`[Septum Telemetry SLOW_WARN] ${jsonLine}`);
+    }
+
+    // Sink 2: Append-only persistent file recorder in .septum/septum.log
+    try {
+      const logPath = this.getLogPath(workspaceRoot);
+      const logDir = dirname(logPath);
+
+      if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
+      }
+
+      // Check for rotation if file exceeds 2MB
+      if (existsSync(logPath)) {
+        try {
+          const stats = statSync(logPath);
+          if (stats.size >= this.MAX_LOG_SIZE_BYTES) {
+            const rotatedPath = `${logPath}.1`;
+            renameSync(logPath, rotatedPath);
+          }
+        } catch {
+          // If stat/rotation fails, proceed to append without crashing
+        }
+      }
+
+      appendFileSync(logPath, `${jsonLine}\n`, "utf8");
+    } catch {
+      // Telemetry file writes must never crash the main application process
+    }
+  }
+}

package/src/core/topology/environment-detector.ts

@@ -556,22 +556,120 @@ export class EnvironmentDetector {
     const realEnv = this.parseEnvFileSafe(path.join(root, ".env"));
     const mergedEnv = new Map([...envMap, ...realEnv]);
     const detectedStorage: string[] = [];
+    const detectedFrom = new Set<string>();
 
     const dbConn = mergedEnv.get("DB_CONNECTION")?.toLowerCase() || "";
     const dbPort = mergedEnv.get("DB_PORT") || "";
 
-    if (dbConn === "mysql" || dbPort === "3306" || [...mergedEnv.keys()].some(k => k.startsWith("MYSQL_"))) {
+    if (dbConn === "mysql" || dbPort === "3306" || [...mergedEnv.keys()].some((k) => k.startsWith("MYSQL_"))) {
       detectedStorage.push("MySQL / MariaDB");
-    } else if (dbConn === "pgsql" || dbPort === "5432" || [...mergedEnv.keys()].some(k => k.startsWith("POSTGRES_"))) {
+      detectedFrom.add(".env");
+    } else if (
+      dbConn === "pgsql" ||
+      dbPort === "5432" ||
+      [...mergedEnv.keys()].some((k) => k.startsWith("POSTGRES_"))
+    ) {
       detectedStorage.push("PostgreSQL");
+      detectedFrom.add(".env");
     } else if (dbConn === "sqlite" || fs.existsSync(path.join(root, "database", "database.sqlite"))) {
       detectedStorage.push("SQLite (File-based)");
+      detectedFrom.add(dbConn === "sqlite" ? ".env" : "database/database.sqlite");
     }
 
     const queueConn = mergedEnv.get("QUEUE_CONNECTION")?.toLowerCase() || "";
     const redisHost = mergedEnv.get("REDIS_HOST");
     if (queueConn === "redis" || redisHost || mergedEnv.has("REDIS_CLIENT")) {
       detectedStorage.push("Redis (Cache & Queues)");
+      detectedFrom.add(".env");
+    }
+
+    // Inspect package.json dependencies & devDependencies
+    const packageJson = this.readJsonSafe(path.join(root, "package.json"));
+    const allPkgDeps: Record<string, string> = {
+      ...(packageJson?.dependencies || {}),
+      ...(packageJson?.devDependencies || {}),
+    };
+
+    const addStorageUnique = (label: string, source: string): void => {
+      if (!detectedStorage.some((s) => s.toLowerCase().startsWith(label.split(" ")[0].toLowerCase()))) {
+        detectedStorage.push(label);
+      }
+      detectedFrom.add(source);
+    };
+
+    if (allPkgDeps["mysql2"] || allPkgDeps["mysql"]) {
+      addStorageUnique("MySQL / MariaDB", "package.json");
+    }
+    if (allPkgDeps["pg"] || allPkgDeps["postgres"]) {
+      addStorageUnique("PostgreSQL", "package.json");
+    }
+    if (allPkgDeps["better-sqlite3"] || allPkgDeps["sqlite3"] || allPkgDeps["@libsql/client"]) {
+      addStorageUnique("SQLite (Embedded / Local WAL)", "package.json");
+    }
+    if (allPkgDeps["redis"] || allPkgDeps["ioredis"]) {
+      addStorageUnique("Redis (Cache & Queues)", "package.json");
+    }
+
+    // Inspect go.mod for Go database drivers
+    const goMod = this.readFileSafe(path.join(root, "go.mod"));
+    if (goMod) {
+      if (goMod.includes("go-sql-driver/mysql") || goMod.includes("driver/mysql")) {
+        addStorageUnique("MySQL / MariaDB", "go.mod");
+      }
+      if (goMod.includes("lib/pq") || goMod.includes("jackc/pgx") || goMod.includes("driver/postgres")) {
+        addStorageUnique("PostgreSQL", "go.mod");
+      }
+      if (
+        goMod.includes("mattn/go-sqlite3") ||
+        goMod.includes("modernc.org/sqlite") ||
+        goMod.includes("driver/sqlite")
+      ) {
+        addStorageUnique("SQLite (Embedded / Local WAL)", "go.mod");
+      }
+      if (goMod.includes("go-redis")) {
+        addStorageUnique("Redis (Cache & Queues)", "go.mod");
+      }
+    }
+
+    // Inspect .septum/septum.db or bun:sqlite usage in source
+    const hasSeptumDb = fs.existsSync(path.join(root, ".septum", "septum.db"));
+    const hasBunSqliteConn =
+      fs.existsSync(path.join(root, "src", "core", "database", "connection.ts")) &&
+      this.readFileSafe(path.join(root, "src", "core", "database", "connection.ts")).includes("bun:sqlite");
+
+    if (hasSeptumDb || hasBunSqliteConn) {
+      addStorageUnique(
+        "SQLite (Embedded / Local WAL)",
+        hasBunSqliteConn ? "src/core/database/connection.ts (bun:sqlite)" : ".septum/septum.db"
+      );
+    } else if (allPkgDeps["@types/bun"] || packageJson?.engines?.bun) {
+      const entryFiles = [
+        path.join(root, "src", "index.ts"),
+        path.join(root, "src", "db.ts"),
+        path.join(root, "src", "database.ts"),
+      ];
+      for (const ef of entryFiles) {
+        if (fs.existsSync(ef) && this.readFileSafe(ef).includes("bun:sqlite")) {
+          addStorageUnique("SQLite (Embedded / Local WAL)", path.relative(root, ef));
+          break;
+        }
+      }
+    }
+
+    if (
+      detectedStorage.length === 0 &&
+      (allPkgDeps["@prisma/client"] || allPkgDeps["drizzle-orm"])
+    ) {
+      const prismaSchema = this.readFileSafe(path.join(root, "prisma", "schema.prisma"));
+      if (prismaSchema.includes('"sqlite"')) {
+        addStorageUnique("SQLite (Embedded / Local WAL)", "prisma/schema.prisma");
+      } else if (prismaSchema.includes('"postgresql"')) {
+        addStorageUnique("PostgreSQL", "prisma/schema.prisma");
+      } else if (prismaSchema.includes('"mysql"')) {
+        addStorageUnique("MySQL / MariaDB", "prisma/schema.prisma");
+      } else {
+        addStorageUnique("SQL Database (Prisma / Drizzle ORM)", "package.json");
+      }
     }
 
     if (detectedStorage.length > 0) {
@@ -580,7 +678,7 @@ export class EnvironmentDetector {
         platform: detectedStorage.join(" + "),
         canonical_tag: "managed_db",
         status: "DETECTED",
-        detected_from: [".env"],
+        detected_from: Array.from(detectedFrom),
         constraints: [
           "Database connection pool limits and socket timeouts must be configured.",
           "Pada Shared Hosting: Akses MySQL biasanya terikat ke 'localhost' / loopback dengan batas koneksi maksimal.",
@@ -713,12 +811,17 @@ export class EnvironmentDetector {
     }
 
     // Distributed Interplay 5: Database Migration Concurrency Invariant
-    const computeNodes = nodes.filter((n) => n.layer === "host" || (n.layer === "runtime" && n.role !== "frontend_spa"));
-    if (computeNodes.length > 1) {
+    const hostLayerNodes = nodes.filter((n) => n.layer === "host");
+    const backendRuntimeNodes = nodes.filter((n) => n.layer === "runtime" && n.role !== "frontend_spa");
+    if (hostLayerNodes.length > 1 || backendRuntimeNodes.length > 1) {
+      const involvedComputeIds = [
+        ...(hostLayerNodes.length > 1 ? hostLayerNodes.map((n) => n.id) : []),
+        ...(backendRuntimeNodes.length > 1 ? backendRuntimeNodes.map((n) => n.id) : []),
+      ];
       interplays.push({
         title: "Distributed Database Migration Concurrency Invariant",
         involved_layers: ["host", "storage"],
-        involved_node_ids: computeNodes.map((n) => n.id),
+        involved_node_ids: involvedComputeIds,
         risk_or_rule: "Terdapat lebih dari 1 instance host/compute (multi-VPS / multi-node) yang terhubung ke database bersama. Menjalankan migrasi database serentak saat deployment memicu deadlock tabel atau migration race condition.",
         required_action: "Pastikan script migrasi (seperti 'artisan migrate --isolated') hanya dijalankan oleh satu designated deploy pipeline runner sebelum node lain menerima traffic.",
       });

package/src/index.ts

@@ -1,21 +1,21 @@
-export * from "./types/index.ts";
-export * from "./core/config/schema.ts";
-export * from "./core/config/loader.ts";
-export * from "./core/database/client.ts";
-export * from "./core/database/repository.ts";
-export * from "./core/parser/extractors/base.ts";
-export * from "./core/parser/tree-sitter.ts";
-export * from "./core/ingestion/pipeline.ts";
-export * from "./core/boundary/evaluator.ts";
-export * from "./core/resolver/call-graph-tracer.ts";
-export * from "./core/resolver/vertical-slice-tracer.ts";
-export * from "./core/topology/types.ts";
-export * from "./core/topology/environment-detector.ts";
-export * from "./mcp/tools/get-environment-topology.ts";
-export * from "./mcp/server.ts";
-export * from "./cli/index.ts";
-
-import { runCLI } from "./cli/index.ts";
-if (import.meta.main) {
-  runCLI(process.argv);
-}
+export * from "./types/index.ts";
+export * from "./core/config/schema.ts";
+export * from "./core/config/loader.ts";
+export * from "./core/database/client.ts";
+export * from "./core/database/repository.ts";
+export * from "./core/parser/extractors/base.ts";
+export * from "./core/parser/tree-sitter.ts";
+export * from "./core/ingestion/pipeline.ts";
+export * from "./core/boundary/evaluator.ts";
+export * from "./core/resolver/call-graph-tracer.ts";
+export * from "./core/resolver/vertical-slice-tracer.ts";
+export * from "./core/topology/types.ts";
+export * from "./core/topology/environment-detector.ts";
+export * from "./mcp/tools/get-environment-topology.ts";
+export * from "./mcp/server.ts";
+export * from "./cli/index.ts";
+
+import { runCLI } from "./cli/index.ts";
+if (import.meta.main) {
+  runCLI(process.argv);
+}