septum 0.1.6 → 0.1.8

package/src/cli/commands/sync.ts

@@ -1,31 +1,41 @@
+import * as path from "node:path";
 import { ConfigLoader } from "../../core/config/loader.ts";
 import { SeptumDatabase } from "../../core/database/client.ts";
 import { SeptumRepository } from "../../core/database/repository.ts";
 import { IngestionPipeline } from "../../core/ingestion/pipeline.ts";
+import { resolveWorkspaceRoot } from "../../core/resolver/path-resolver.ts";
 
 export interface SyncCommandOptions {
   json?: boolean;
+  workspaceRoot?: string;
+  dbPath?: string;
 }
 
 export async function handleSyncCommand(options: SyncCommandOptions = {}): Promise<void> {
-  const config = ConfigLoader.load();
-  const db = new SeptumDatabase(config.settings.db_path);
-  const repo = new SeptumRepository(db.raw);
-  const pipeline = new IngestionPipeline(repo);
+  const root = options.workspaceRoot || resolveWorkspaceRoot();
+  const config = ConfigLoader.load(options.dbPath, root);
+  const resolvedDbPath = options.dbPath
+    ? (path.isAbsolute(options.dbPath) ? options.dbPath : path.join(root, options.dbPath))
+    : (path.isAbsolute(config.settings.db_path) ? config.settings.db_path : path.join(root, config.settings.db_path));
+  const db = new SeptumDatabase(resolvedDbPath);
+  try {
+    const repo = new SeptumRepository(db.raw);
+    const pipeline = new IngestionPipeline(repo, root);
 
-  const metrics = await pipeline.run(config);
+    const metrics = await pipeline.run(config);
 
-  if (options.json) {
-    console.log(JSON.stringify(metrics, null, 2));
-  } else {
-    console.log(
-      `[Septum Sync] Ingested in ${metrics.duration_ms.toFixed(0)}ms: ` +
-        `${metrics.files_updated} updated/added, ` +
-        `${metrics.files_skipped} unchanged, ` +
-        `${metrics.symbols_indexed} symbols, ` +
-        `${metrics.dependencies_indexed} deps.`
-    );
+    if (options.json) {
+      console.log(JSON.stringify(metrics, null, 2));
+    } else {
+      console.log(
+        `[Septum Sync] Ingested in ${metrics.duration_ms.toFixed(0)}ms: ` +
+          `${metrics.files_updated} updated/added, ` +
+          `${metrics.files_skipped} unchanged, ` +
+          `${metrics.symbols_indexed} symbols, ` +
+          `${metrics.dependencies_indexed} deps.`
+      );
+    }
+  } finally {
+    db.close();
   }
-
-  db.close();
 }

package/src/cli/commands/topology.ts

@@ -1,62 +1,103 @@
+import { join } from "node:path";
 import { SeptumDatabase } from "../../core/database/client.ts";
 import { SeptumRepository } from "../../core/database/repository.ts";
 import { EnvironmentDetector } from "../../core/topology/environment-detector.ts";
 import type { EnvironmentLayer, TopologyNode } from "../../core/topology/types.ts";
 
+const VALID_LAYERS = new Set<EnvironmentLayer>([
+  "edge",
+  "gateway",
+  "host",
+  "runtime",
+  "storage",
+  "telemetry",
+]);
+
 export async function handleTopologyCommand(
   subcommand?: string,
   arg1?: string,
   arg2?: string,
   arg3?: string,
-  arg4?: string
+  arg4?: string,
+  workspaceRoot?: string
 ): Promise<void> {
-  const cwd = process.cwd();
-  const db = new SeptumDatabase();
-  const repo = new SeptumRepository(db.raw);
+  const normalizedSub = subcommand?.trim().toLowerCase();
 
-  if (subcommand === "resolve" && arg1 && arg2) {
-    const layer = arg1.toLowerCase() as EnvironmentLayer;
-    const platform = arg2;
-    // Fix: Preserve existing constraints instead of overwriting with empty array
-    const existing = repo.environment.getLayer(layer);
-    repo.environment.saveLayer({
-      layer,
-      platform,
-      canonical_tag: EnvironmentDetector.matchCanonicalTag(platform),
-      status: "VERIFIED",
-      detected_from: ["CLI Manual Resolution"],
-      constraints: existing?.constraints && existing.constraints.length > 0 ? existing.constraints : [
-        `Configured manually as '${platform}'.`
-      ],
-    });
-    console.log(`[Septum Topology] Layer '${layer}' successfully verified as '${platform}' in SQLite SSOT.\n`);
-  } else if (subcommand === "add-node" && arg1 && arg2 && arg3) {
-    const nodeId = arg1;
-    const layer = arg2.toLowerCase() as EnvironmentLayer;
-    const platform = arg3;
-    const domainOrIp = arg4;
+  if (normalizedSub && normalizedSub !== "resolve" && normalizedSub !== "add-node" && normalizedSub !== "remove-node" && normalizedSub !== "clear") {
+    throw new Error(`Unknown topology subcommand: '${subcommand}'. Valid subcommands: resolve, add-node, remove-node, clear.`);
+  }
 
-    const node: TopologyNode = {
-      id: nodeId,
-      layer,
-      name: nodeId,
-      platform,
-      canonical_tag: EnvironmentDetector.matchCanonicalTag(platform),
-      domain_or_ip: domainOrIp,
-      status: "VERIFIED",
-      detected_from: ["CLI Manual Node Resolution"],
-      constraints: [`Node added manually with platform '${platform}'.`],
-    };
-    repo.environment.saveNode(node);
-    console.log(`[Septum Topology] Node '${nodeId}' (${layer.toUpperCase()}) added to distributed topology graph.\n`);
-  } else if (subcommand === "remove-node" && arg1) {
-    repo.environment.deleteNode(arg1);
-    console.log(`[Septum Topology] Node '${arg1}' removed from distributed topology graph.\n`);
-  } else if (subcommand === "clear") {
-    repo.environment.clearAll();
-    console.log("[Septum Topology] Cleared environment topology and nodes in SQLite SSOT.\n");
+  if (normalizedSub === "resolve") {
+    if (!arg1 || !arg2) {
+      throw new Error("Missing required arguments for 'topology resolve'. Usage: septum topology resolve <layer> <platform>");
+    }
+    const layerCandidate = arg1.trim().toLowerCase() as EnvironmentLayer;
+    if (!VALID_LAYERS.has(layerCandidate)) {
+      throw new Error(`Invalid environment layer '${arg1}'. Valid layers: ${Array.from(VALID_LAYERS).join(", ")}`);
+    }
+  } else if (normalizedSub === "add-node") {
+    if (!arg1 || !arg2 || !arg3) {
+      throw new Error("Missing required arguments for 'topology add-node'. Usage: septum topology add-node <id> <layer> <platform> [domain_or_ip]");
+    }
+    const layerCandidate = arg2.trim().toLowerCase() as EnvironmentLayer;
+    if (!VALID_LAYERS.has(layerCandidate)) {
+      throw new Error(`Invalid environment layer '${arg2}'. Valid layers: ${Array.from(VALID_LAYERS).join(", ")}`);
+    }
+  } else if (normalizedSub === "remove-node") {
+    if (!arg1) {
+      throw new Error("Missing required argument for 'topology remove-node'. Usage: septum topology remove-node <id>");
+    }
   }
 
+  const cwd = workspaceRoot || process.cwd();
+  const dbPath = workspaceRoot ? join(workspaceRoot, ".septum/septum.db") : undefined;
+  const db = new SeptumDatabase(dbPath);
+  const repo = new SeptumRepository(db.raw);
+
+  try {
+    if (normalizedSub === "resolve" && arg1 && arg2) {
+      const layer = arg1.trim().toLowerCase() as EnvironmentLayer;
+      const platform = arg2;
+      // Fix: Preserve existing constraints instead of overwriting with empty array
+      const existing = repo.environment.getLayer(layer);
+      repo.environment.saveLayer({
+        layer,
+        platform,
+        canonical_tag: EnvironmentDetector.matchCanonicalTag(platform),
+        status: "VERIFIED",
+        detected_from: ["CLI Manual Resolution"],
+        constraints: existing?.constraints && existing.constraints.length > 0 ? existing.constraints : [
+          `Configured manually as '${platform}'.`
+        ],
+      });
+      console.log(`[Septum Topology] Layer '${layer}' successfully verified as '${platform}' in SQLite SSOT.\n`);
+    } else if (normalizedSub === "add-node" && arg1 && arg2 && arg3) {
+      const nodeId = arg1;
+      const layer = arg2.trim().toLowerCase() as EnvironmentLayer;
+      const platform = arg3;
+      const domainOrIp = arg4;
+
+      const node: TopologyNode = {
+        id: nodeId,
+        layer,
+        name: nodeId,
+        platform,
+        canonical_tag: EnvironmentDetector.matchCanonicalTag(platform),
+        domain_or_ip: domainOrIp,
+        status: "VERIFIED",
+        detected_from: ["CLI Manual Node Resolution"],
+        constraints: [`Node added manually with platform '${platform}'.`],
+      };
+      repo.environment.saveNode(node);
+      console.log(`[Septum Topology] Node '${nodeId}' (${layer.toUpperCase()}) added to distributed topology graph.\n`);
+    } else if (normalizedSub === "remove-node" && arg1) {
+      repo.environment.deleteNode(arg1);
+      console.log(`[Septum Topology] Node '${arg1}' removed from distributed topology graph.\n`);
+    } else if (normalizedSub === "clear") {
+      repo.environment.clearAll();
+      console.log("[Septum Topology] Cleared environment topology and nodes in SQLite SSOT.\n");
+    }
+
   const topology = EnvironmentDetector.detect(cwd, repo);
 
   console.log("================================================================================");
@@ -113,7 +154,8 @@ export async function handleTopologyCommand(
     console.log("  septum topology add-node host:vps-worker host \"Ubuntu 24.04 (Dedicated Worker)\" 10.0.0.6");
   }
 
-  console.log("================================================================================\n");
-
-  db.close();
+    console.log("================================================================================\n");
+  } finally {
+    db.close();
+  }
 }

package/src/cli/index.ts

@@ -3,13 +3,9 @@ import { SessionManager } from "../core/session/session-manager.ts";
 import { SEPTUM_VERSION } from "../version.ts";
 import { handleCheckCommand } from "./commands/check.ts";
 import { handleHookCommand } from "./commands/hook.ts";
-import { handleIngestCommand } from "./commands/ingest.ts";
 import { handleInitCommand } from "./commands/init.ts";
 import { handleTopologyCommand } from "./commands/topology.ts";
-import { handleLocateCommand } from "./commands/locate.ts";
-import { handleQueryCommand } from "./commands/query.ts";
 import { handleServeCommand } from "./commands/serve.ts";
-import { handleSliceCommand } from "./commands/slice.ts";
 import { handleSyncCommand } from "./commands/sync.ts";
 
 export async function runCLI(argv: string[]): Promise<void> {
@@ -22,13 +18,8 @@ export async function runCLI(argv: string[]): Promise<void> {
         version: { type: "boolean", short: "v" },
         force: { type: "boolean", short: "f" },
         json: { type: "boolean" },
-        full: { type: "boolean" },
-        file: { type: "string" },
         strict: { type: "boolean" },
         staged: { type: "boolean" },
-        domain: { type: "string", short: "d" },
-        "max-depth": { type: "string" },
-        archetype: { type: "string", short: "a" },
         feature: { type: "string" },
       },
       allowPositionals: true,
@@ -61,55 +52,12 @@ export async function runCLI(argv: string[]): Promise<void> {
         break;
       }
 
-      case "ingest": {
-        await handleIngestCommand();
-        break;
-      }
-
       case "sync": {
         const json = Boolean(flags.json);
         await handleSyncCommand({ json });
         break;
       }
 
-      case "query": {
-        const domainName = positionals[1];
-        const archetype = typeof flags.archetype === "string" ? flags.archetype : undefined;
-        const jsonOutput = Boolean(flags.json);
-        const full = Boolean(flags.full);
-        const file = typeof flags.file === "string" ? flags.file : undefined;
-        await handleQueryCommand(domainName, archetype, { json: jsonOutput, full, file });
-        break;
-      }
-
-      case "locate": {
-        const query = positionals[1];
-        if (!query) {
-          console.error("Usage: septum locate <symbol-or-error> [--domain <domain>] [--json]");
-          process.exit(1);
-        }
-        const domain = typeof flags.domain === "string" ? flags.domain : undefined;
-        const json = Boolean(flags.json);
-        await handleLocateCommand(query, { domain, json });
-        break;
-      }
-
-      case "slice": {
-        const query = positionals[1];
-        if (!query) {
-          console.error("Usage: septum slice <route-or-intent> [-d|--max-depth <number>] [--json]");
-          process.exit(1);
-        }
-        const json = Boolean(flags.json);
-        const rawDepth = flags["max-depth"] ?? flags.domain;
-        const parsedDepth = rawDepth !== undefined ? Number(rawDepth) : 5;
-        const maxDepth = !Number.isNaN(parsedDepth)
-          ? Math.min(Math.max(Math.trunc(parsedDepth), 1), 8)
-          : 5;
-        await handleSliceCommand(query, { json, maxDepth });
-        break;
-      }
-
       case "check": {
         const strict = Boolean(flags.strict);
         const staged = Boolean(flags.staged);
@@ -132,7 +80,7 @@ export async function runCLI(argv: string[]): Promise<void> {
       case "feature": {
         const sub = positionals[1];
         if (sub === "clear") {
-          const cleared = SessionManager.clearActiveSession(process.cwd());
+          const cleared = SessionManager.clearActiveSession(process.cwd(), undefined, Boolean(flags.force));
           if (cleared) {
             console.log("✓ Active feature session successfully cleared.");
           } else {
@@ -184,29 +132,21 @@ USAGE:
   septum [flags]
 
 COMMANDS:
-  Catalog & Ingestion:
+  Core Lifecycle & Indexing:
     init                  Initialize configuration, gitignore, pre-commit hook, and catalog
-                          Flags: -f, --force
-    ingest                Full AST scan and synchronization to SQLite database
-    sync                  Incremental fast synchronization of modified files
+                          Flags: -f, --force (regenerate Septum-owned hooks & harness artifacts; preserves DB, domain policies, and user hooks)
+    sync                  Codebase AST synchronization and catalog update (full or incremental)
                           Flags: --json
 
-  Structural Discovery:
-    query [domain]        Query structural catalog for a domain or whole project
-                          Flags: -a, --archetype <name>, --full, --file <filter>, --json
-    locate <query>        Locate symbol, class, interface, method, or error source
-                          Flags: -d, --domain <name>, --json
-    slice <route|intent>  Trace end-to-end vertical execution slice for route/intent
-                          Flags: -d, --max-depth <number>, --json
-
   Boundary & Enforcement:
     check                 Audit codebase for cross-domain boundary violations
-                          Flags: --strict, --staged, --feature <name>
+                          Flags: --strict, --staged, --feature <name>, --json
     feature [status|clear] View or release active feature context session lock
+                          Flags: --force (explicit recovery of another owner's session)
     hook [subhook]        Internal pre-tool guardrail hook (e.g. pre-write)
 
   Environment & Topology:
-    topology [action]     Inspect 6-layer environment topology & distributed nodes
+    topology, env [action] Inspect 6-layer environment topology & distributed nodes
                           Subcommands: resolve <layer> <platform>, add-node, remove-node, clear
 
   Daemon & Protocol:
@@ -215,6 +155,5 @@ COMMANDS:
 GLOBAL FLAGS:
   -h, --help              Show this help message
   -v, --version           Show current version
-  --json                  Output formatted JSON metrics / results
 `);
 }