septum 0.1.2 → 0.1.3

package/src/mcp/schemas.ts

@@ -1,68 +1,238 @@
 import { z } from "zod";
 
-export const GetDomainCatalogSchema = z.object({
-  domain: z.string().optional(),
-  archetype: z.string().optional(),
-});
+function withAliases(raw: unknown, aliases: Record<string, string>): unknown {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return raw;
+  const obj = { ...(raw as Record<string, unknown>) };
+  for (const [alias, target] of Object.entries(aliases)) {
+    if (obj[alias] !== undefined && obj[target] === undefined) {
+      obj[target] = obj[alias];
+    }
+  }
+  return obj;
+}
+
+function normalizeBoundaryArgs(raw: unknown): unknown {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return raw;
+  const obj = { ...(raw as Record<string, unknown>) };
+  const aliases: Record<string, string> = {
+    filePath: "file_path",
+    file: "file_path",
+    path: "file_path",
+    filePaths: "file_paths",
+    files: "file_paths",
+    paths: "file_paths",
+    proposedImports: "proposed_imports",
+    imports: "proposed_imports",
+    featureKey: "feature_key",
+    feature: "feature_key",
+  };
+  for (const [alias, target] of Object.entries(aliases)) {
+    if (obj[alias] !== undefined && obj[target] === undefined) {
+      obj[target] = obj[alias];
+    }
+  }
+  if (Array.isArray(obj.file_path) && !obj.file_paths) {
+    obj.file_paths = obj.file_path;
+    delete obj.file_path;
+  }
+  if (typeof obj.file_paths === "string" && !obj.file_path) {
+    obj.file_path = obj.file_paths;
+    delete obj.file_paths;
+  }
+  return obj;
+}
+
+export const GetDomainCatalogSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      domain_name: "domain",
+      domainName: "domain",
+      name: "domain",
+      archetype_filter: "archetype",
+      archetypeFilter: "archetype",
+      type: "archetype",
+      workspace: "workspace_path",
+      workspacePath: "workspace_path",
+      project_root: "workspace_path",
+      target_path: "workspace_path",
+      path: "workspace_path",
+    }),
+  z.object({
+    domain: z.string().optional(),
+    archetype: z.string().optional(),
+    workspace_path: z.string().optional(),
+  })
+);
 export type GetDomainCatalogArgs = z.infer<typeof GetDomainCatalogSchema>;
 
-export const GetFeatureContextSchema = z.object({
-  feature: z.string().min(1, "feature is required"),
-});
+export const GetFeatureContextSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      feature_key: "feature",
+      featureKey: "feature",
+      name: "feature",
+      workspace: "workspace_path",
+      workspacePath: "workspace_path",
+    }),
+  z.object({
+    feature: z.string().min(1, "feature is required"),
+    workspace_path: z.string().optional(),
+  })
+);
 export type GetFeatureContextArgs = z.infer<typeof GetFeatureContextSchema>;
 
-export const LocateSymbolSchema = z.object({
-  query: z.string().min(1, "query is required"),
-  domain: z.string().optional(),
-  limit: z.number().int().positive().optional().default(10),
-});
+export const LocateSymbolSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      symbol: "query",
+      name: "query",
+      symbol_name: "query",
+      symbolName: "query",
+      target: "query",
+      domain_name: "domain",
+      domainName: "domain",
+      max: "limit",
+      workspace: "workspace_path",
+      workspacePath: "workspace_path",
+      project_root: "workspace_path",
+      target_path: "workspace_path",
+      path: "workspace_path",
+    }),
+  z.object({
+    query: z.string().min(1, "query is required"),
+    domain: z.string().optional(),
+    limit: z.number().int().positive().optional().default(10),
+    workspace_path: z.string().optional(),
+  })
+);
 export type LocateSymbolArgs = z.infer<typeof LocateSymbolSchema>;
 
-export const GetSymbolSchema = z.object({
-  symbol: z.string().min(1, "symbol is required"),
-  domain: z.string().optional(),
-  include_dependencies: z.boolean().optional().default(true),
-});
+export const GetSymbolSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      query: "symbol",
+      name: "symbol",
+      symbol_name: "symbol",
+      symbolName: "symbol",
+      target: "symbol",
+      domain_name: "domain",
+      domainName: "domain",
+      includeDependencies: "include_dependencies",
+      include_deps: "include_dependencies",
+      includeDeps: "include_dependencies",
+      dependencies: "include_dependencies",
+      deps: "include_dependencies",
+    }),
+  z.object({
+    symbol: z.string().min(1, "symbol is required"),
+    domain: z.string().optional(),
+    include_dependencies: z.boolean().optional().default(true),
+  })
+);
 export type GetSymbolArgs = z.infer<typeof GetSymbolSchema>;
 
-export const GetSymbolImpactSchema = z.object({
-  symbol: z.string().min(1, "symbol is required"),
-});
+export const GetSymbolImpactSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      query: "symbol",
+      name: "symbol",
+      symbol_name: "symbol",
+      symbolName: "symbol",
+      file_path: "symbol",
+      filePath: "symbol",
+      file: "symbol",
+      path: "symbol",
+      target: "symbol",
+    }),
+  z.object({
+    symbol: z.string().min(1, "symbol is required"),
+  })
+);
 export type GetSymbolImpactArgs = z.infer<typeof GetSymbolImpactSchema>;
 
-export const TraceVerticalSliceSchema = z.object({
-  query: z.string().min(1, "query is required"),
-  max_depth: z.number().int().positive().optional().default(5),
-});
+export const TraceVerticalSliceSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      route: "query",
+      uri: "query",
+      route_uri: "query",
+      routeUri: "query",
+      symbol: "query",
+      name: "query",
+      feature: "query",
+      feature_key: "query",
+      featureKey: "query",
+      maxDepth: "max_depth",
+      depth: "max_depth",
+    }),
+  z.object({
+    query: z.string().min(1, "query is required"),
+    max_depth: z.number().int().positive().optional().default(5),
+  })
+);
 export type TraceVerticalSliceArgs = z.infer<typeof TraceVerticalSliceSchema>;
 
-export const CheckBoundarySchema = z.object({
-  file_path: z.string().optional(),
-  file_paths: z.array(z.string()).optional(),
-  proposed_imports: z.array(z.string()).default([]),
-  feature_key: z.string().optional(),
-});
+export const CheckBoundarySchema = z.preprocess(
+  normalizeBoundaryArgs,
+  z.object({
+    file_path: z.string().optional(),
+    file_paths: z.array(z.string()).optional(),
+    proposed_imports: z.array(z.string()).default([]),
+    feature_key: z.string().optional(),
+  })
+);
 export type CheckBoundaryArgs = z.infer<typeof CheckBoundarySchema>;
 
-export const GetSymbolHotspotsSchema = z.object({
-  domain: z.string().optional(),
-  limit: z.number().int().positive().optional().default(10),
-});
+export const GetSymbolHotspotsSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      domain_name: "domain",
+      domainName: "domain",
+      max: "limit",
+    }),
+  z.object({
+    domain: z.string().optional(),
+    limit: z.number().int().positive().optional().default(10),
+  })
+);
 export type GetSymbolHotspotsArgs = z.infer<typeof GetSymbolHotspotsSchema>;
 
-export const RegisterDomainSchema = z.object({
-  name: z.string().min(1, "Domain name is required"),
-  root: z.string().min(1, "Domain root path is required"),
-  description: z.string().optional(),
-  allowed_dependencies: z.array(z.string()).optional(),
-  forbidden_dependencies: z.array(z.string()).optional(),
-  archetypes: z.record(z.string()).optional(),
-  ingest_now: z.boolean().optional().default(false),
-});
+export const RegisterDomainSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      domain: "name",
+      domain_name: "name",
+      domainName: "name",
+      root_path: "root",
+      rootPath: "root",
+      path: "root",
+      allowedDependencies: "allowed_dependencies",
+      allowed: "allowed_dependencies",
+      forbiddenDependencies: "forbidden_dependencies",
+      forbidden: "forbidden_dependencies",
+      archetype: "archetypes",
+      ingestNow: "ingest_now",
+    }),
+  z.object({
+    name: z.string().min(1, "Domain name is required"),
+    root: z.string().min(1, "Domain root path is required"),
+    description: z.string().optional(),
+    allowed_dependencies: z.array(z.string()).optional(),
+    forbidden_dependencies: z.array(z.string()).optional(),
+    archetypes: z.record(z.string()).optional(),
+    ingest_now: z.boolean().optional().default(false),
+  })
+);
 export type RegisterDomainArgs = z.infer<typeof RegisterDomainSchema>;
 
-export const AutoDiscoverDomainsSchema = z.object({
-  persist: z.boolean().optional().default(true),
-});
+export const AutoDiscoverDomainsSchema = z.preprocess(
+  (args) =>
+    withAliases(args, {
+      save: "persist",
+    }),
+  z.object({
+    persist: z.boolean().optional().default(true),
+  })
+);
 export type AutoDiscoverDomainsArgs = z.infer<typeof AutoDiscoverDomainsSchema>;
 

package/src/mcp/server.ts

@@ -54,12 +54,51 @@ import {
   TraceVerticalSliceSchema,
 } from "./schemas.ts";
 import { SEPTUM_VERSION } from "../version.ts";
+import { resolveWorkspaceRoot } from "../core/resolver/path-resolver.ts";
+import type { ValidatedSeptumConfig } from "../core/config/schema.ts";
 
-export async function runMCPServer(): Promise<void> {
-  const config = ConfigLoader.load();
+interface WorkspaceContext {
+  root: string;
+  config: ValidatedSeptumConfig;
+  db: SeptumDatabase;
+  repo: SeptumRepository;
+  evaluator: BoundaryEvaluator;
+  pipeline: IngestionPipeline;
+}
+
+const workspaceContextCache = new Map<string, WorkspaceContext>();
+
+function extractPathHint(args: Record<string, any> | undefined): string | undefined {
+  if (!args) return undefined;
+  if (typeof args.workspace_path === "string" && args.workspace_path) return args.workspace_path;
+  if (typeof args.target_path === "string" && args.target_path) return args.target_path;
+  if (typeof args.project_root === "string" && args.project_root) return args.project_root;
+  if (typeof args.file_path === "string" && args.file_path) return args.file_path;
+  if (Array.isArray(args.file_paths) && args.file_paths[0]) return args.file_paths[0];
+  if (typeof args.root === "string" && args.root) return args.root;
+  return undefined;
+}
+
+function getWorkspaceContext(pathHint?: string): WorkspaceContext {
+  const root = resolveWorkspaceRoot(pathHint);
+  let ctx = workspaceContextCache.get(root);
+  if (ctx) {
+    return ctx;
+  }
+
+  const config = ConfigLoader.load(undefined, root);
   const db = new SeptumDatabase(config.settings.db_path);
   const repo = new SeptumRepository(db.raw);
   const evaluator = new BoundaryEvaluator(repo);
+  const pipeline = new IngestionPipeline(repo, root);
+
+  ctx = { root, config, db, repo, evaluator, pipeline };
+  workspaceContextCache.set(root, ctx);
+  return ctx;
+}
+
+export async function runMCPServer(): Promise<void> {
+  const initialCtx = getWorkspaceContext();
 
   const server = new Server(
     {
@@ -297,7 +336,10 @@ export async function runMCPServer(): Promise<void> {
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     const startTime = performance.now();
-    const activeSession = SessionManager.getActiveSession(process.cwd());
+    const pathHint = extractPathHint(args as Record<string, any>);
+    const ctx = getWorkspaceContext(pathHint);
+
+    const activeSession = SessionManager.getActiveSession(ctx.root);
     const sessionPayload = activeSession
       ? { feature_key: activeSession.feature_key, domain: activeSession.domain }
       : null;
@@ -316,7 +358,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleGetDomainCatalog(repo, config, parsed.data);
+        return handleGetDomainCatalog(ctx.repo, ctx.config, parsed.data, ctx.root);
       } else if (name === "septum_get_feature_context") {
         const parsed = GetFeatureContextSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -330,7 +372,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleGetFeatureContext(repo, config, parsed.data);
+        return handleGetFeatureContext(ctx.repo, ctx.config, parsed.data);
       } else if (name === "septum_locate_symbol") {
         const parsed = LocateSymbolSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -344,7 +386,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleLocateSymbol(repo, config, parsed.data);
+        return await handleLocateSymbol(ctx.repo, ctx.config, parsed.data, ctx.pipeline, ctx.root);
       } else if (name === "septum_get_symbol") {
         const parsed = GetSymbolSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -358,7 +400,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleGetSymbol(repo, config, parsed.data);
+        return handleGetSymbol(ctx.repo, ctx.config, parsed.data);
       } else if (name === "septum_get_symbol_impact") {
         const parsed = GetSymbolImpactSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -372,7 +414,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleGetSymbolImpact(repo, config, parsed.data);
+        return handleGetSymbolImpact(ctx.repo, ctx.config, parsed.data);
       } else if (name === "septum_trace_vertical_slice") {
         const parsed = TraceVerticalSliceSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -386,7 +428,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleTraceVerticalSlice(repo, config, parsed.data);
+        return handleTraceVerticalSlice(ctx.repo, ctx.config, parsed.data);
       } else if (name === "septum_clear_feature_context") {
         const cleared = handleClearFeatureContext();
         return {
@@ -412,7 +454,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleCheckBoundary(evaluator, config, parsed.data);
+        return handleCheckBoundary(ctx.evaluator, ctx.config, parsed.data, ctx.repo);
       } else if (name === "septum_get_symbol_hotspots") {
         const parsed = GetSymbolHotspotsSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -426,7 +468,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return handleGetSymbolHotspots(repo, config, parsed.data);
+        return handleGetSymbolHotspots(ctx.repo, ctx.config, parsed.data);
       } else if (name === "septum_register_domain") {
         const parsed = RegisterDomainSchema.safeParse(args ?? {});
         if (!parsed.success) {
@@ -440,7 +482,7 @@ export async function runMCPServer(): Promise<void> {
             ],
           };
         }
-        return await handleRegisterDomain(repo, config, parsed.data);
+        return await handleRegisterDomain(ctx.repo, ctx.config, parsed.data);
       } else {
         throw new Error(`Unknown tool: '${name}'`);
       }
@@ -522,7 +564,7 @@ export async function runMCPServer(): Promise<void> {
   ]);
 
   try {
-    const bgPipeline = new IngestionPipeline(repo);
+    const bgPipeline = initialCtx.pipeline;
     const cwd = process.cwd();
 
     fsWatcher = watch(cwd, { recursive: true }, (_event, filename) => {
@@ -569,13 +611,14 @@ export async function runMCPServer(): Promise<void> {
         // Ignore watcher close errors during shutdown
       }
     }
-    try {
-      db.close();
-      console.error("[Septum MCP] Database connection closed cleanly.");
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`[Septum MCP] Error closing database during cleanup: ${msg}`);
+    for (const ctx of workspaceContextCache.values()) {
+      try {
+        ctx.db.close();
+      } catch (err) {
+        // Ignore close error during shutdown
+      }
     }
+    console.error("[Septum MCP] All database connections closed cleanly.");
     process.exit(0);
   };
 
@@ -590,11 +633,12 @@ export async function runMCPServer(): Promise<void> {
         // Ignore watcher close errors
       }
     }
-    try {
-      db.close();
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`[Septum MCP] Error closing database on beforeExit: ${msg}`);
+    for (const ctx of workspaceContextCache.values()) {
+      try {
+        ctx.db.close();
+      } catch {
+        // Ignore close error
+      }
     }
   });
 

package/src/mcp/tools/check-boundary.ts

@@ -1,23 +1,44 @@
 import type { BoundaryEvaluator } from "../../core/boundary/evaluator.ts";
 import type { ValidatedSeptumConfig } from "../../core/config/schema.ts";
+import type { SeptumRepository } from "../../core/database/repository.ts";
 
 export interface CheckBoundaryArgs {
   file_path?: string;
+  filePath?: string;
+  file?: string;
+  path?: string;
   file_paths?: string[];
+  filePaths?: string[];
+  files?: string[];
+  paths?: string[];
   proposed_imports?: string[];
+  proposedImports?: string[];
+  imports?: string[];
   feature_key?: string;
+  featureKey?: string;
+  feature?: string;
 }
 
 export function handleCheckBoundary(
   evaluator: BoundaryEvaluator,
   config: ValidatedSeptumConfig,
-  args: CheckBoundaryArgs
+  args: CheckBoundaryArgs,
+  repo?: SeptumRepository
 ) {
+  const rawFilePaths = args.file_paths ?? args.filePaths ?? args.files ?? args.paths;
+  const rawFilePath = args.file_path ?? args.filePath ?? args.file ?? args.path;
+  const proposedImports = args.proposed_imports ?? args.proposedImports ?? args.imports ?? [];
+  const featureKey = args.feature_key ?? args.featureKey ?? args.feature;
+
   const filesToCheck: string[] = [];
-  if (args.file_paths && Array.isArray(args.file_paths) && args.file_paths.length > 0) {
-    filesToCheck.push(...args.file_paths);
-  } else if (args.file_path) {
-    filesToCheck.push(args.file_path);
+  if (rawFilePaths && Array.isArray(rawFilePaths) && rawFilePaths.length > 0) {
+    filesToCheck.push(...rawFilePaths);
+  } else if (rawFilePath) {
+    if (Array.isArray(rawFilePath)) {
+      filesToCheck.push(...rawFilePath);
+    } else {
+      filesToCheck.push(rawFilePath);
+    }
   } else {
     throw new Error("Missing required argument: specify either 'file_path' or 'file_paths'");
   }
@@ -25,11 +46,20 @@ export function handleCheckBoundary(
   // Multi-file batch evaluation
   if (filesToCheck.length > 1) {
     const results = filesToCheck.map((filePath) => {
-      const violations = evaluator.evaluate(filePath, args.proposed_imports ?? [], args.feature_key, config);
+      const violations = evaluator.evaluate(filePath, proposedImports, featureKey, config);
+      const impact = repo?.getFileInboundImpact(filePath);
       return {
         file: filePath,
         status: violations.length > 0 ? "rejected" : "approved",
         violations,
+        impact_summary: impact
+          ? {
+              direct_dependents: impact.direct_dependents_count,
+              top_consumers: impact.top_consumers,
+              symbols_count: impact.symbols_count,
+              risk_level: impact.risk_level,
+            }
+          : undefined,
       };
     });
 
@@ -60,7 +90,8 @@ export function handleCheckBoundary(
 
   // Single file evaluation (backward-compatible output)
   const singleFile = filesToCheck[0];
-  const violations = evaluator.evaluate(singleFile, args.proposed_imports ?? [], args.feature_key, config);
+  const violations = evaluator.evaluate(singleFile, proposedImports, featureKey, config);
+  const impact = repo?.getFileInboundImpact(singleFile);
 
   if (violations.length > 0) {
     return {
@@ -73,6 +104,14 @@ export function handleCheckBoundary(
               file: singleFile,
               violations_count: violations.length,
               violations,
+              impact_summary: impact
+                ? {
+                    direct_dependents: impact.direct_dependents_count,
+                    top_consumers: impact.top_consumers,
+                    symbols_count: impact.symbols_count,
+                    risk_level: impact.risk_level,
+                  }
+                : undefined,
               message: "Boundary violation detected. Proposed imports violate bounded context architecture.",
             },
             null,
@@ -91,7 +130,18 @@ export function handleCheckBoundary(
           {
             status: "approved",
             file: singleFile,
-            message: "No boundary violations detected. Proposed imports are permissible.",
+            impact_summary: impact
+              ? {
+                  direct_dependents: impact.direct_dependents_count,
+                  top_consumers: impact.top_consumers,
+                  symbols_count: impact.symbols_count,
+                  risk_level: impact.risk_level,
+                }
+              : undefined,
+            message:
+              impact && impact.direct_dependents_count > 0
+                ? `No boundary violations detected. Caution: ${impact.direct_dependents_count} dependent file(s) consume this file.`
+                : "No boundary violations detected. Proposed imports are permissible.",
           },
           null,
           2

package/src/mcp/tools/get-domain-catalog.ts

@@ -6,15 +6,45 @@ import type { SeptumRepository } from "../../core/database/repository.ts";
 export interface GetDomainCatalogArgs {
   domain?: string;
   archetype_filter?: string;
+  workspace_path?: string;
 }
 
 export function handleGetDomainCatalog(
   repo: SeptumRepository,
   config: ValidatedSeptumConfig,
-  args: GetDomainCatalogArgs
+  args: GetDomainCatalogArgs,
+  workspaceRoot?: string
 ) {
   if (!args.domain) {
     const allDomains = repo.getAllDomains();
+    if (allDomains.length === 0) {
+      const root = workspaceRoot || process.cwd();
+      const diagnostic = {
+        status: "NOT_INDEXED",
+        total_domains: 0,
+        message: `Workspace '${root}' belum memiliki domain terdaftar dalam Septum catalog.`,
+        suggested_action: {
+          tool: "septum_register_domain",
+          params: {
+            name: "core",
+            root: "src",
+            ingest_now: true,
+          },
+        },
+        agent_guidance:
+          "Panggil tool 'septum_register_domain(name: \"core\", root: \"src\", ingest_now: true)' untuk mendaftarkan dan mengindeks domain utama secara otomatis, atau jalankan 'septum init' di terminal workspace.",
+      };
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify(diagnostic, null, 2),
+          },
+        ],
+        metadata: diagnostic,
+      };
+    }
+
     const projectType = repo.getMeta("project_type") || "generic";
     const framework = repo.getMeta("framework") || "unknown";
     const archStyle = repo.getMeta("architecture_style") || "modular";