septum 0.1.3 → 0.1.5

package/src/mcp/tools/register-feature.ts

@@ -0,0 +1,100 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ValidatedSeptumConfig } from "../../core/config/schema.ts";
+import type { SeptumRepository } from "../../core/database/repository.ts";
+import { SessionManager } from "../../core/session/session-manager.ts";
+import type { FeatureConfig, RegisterFeatureArgs } from "../../types/index.ts";
+
+export async function handleRegisterFeature(
+  _repo: SeptumRepository,
+  config: ValidatedSeptumConfig,
+  args: RegisterFeatureArgs,
+  workspaceRoot: string = process.cwd()
+) {
+  const featureKey = (args.feature_key || (args as unknown as Record<string, unknown>).feature || "").toString().trim();
+  const domain = (args.domain || (args as unknown as Record<string, unknown>).domain_name || "").toString().trim();
+
+  if (!featureKey || !domain) {
+    throw new Error("Missing required arguments: 'feature_key' and 'domain' are required.");
+  }
+
+  const rawTouchpoints = args.allowed_touchpoints ?? [];
+  const allowedTouchpoints = Array.isArray(rawTouchpoints)
+    ? rawTouchpoints
+    : typeof rawTouchpoints === "string"
+    ? [rawTouchpoints]
+    : [];
+
+  const rawReuse = args.reuse_symbols;
+  const reuseSymbols: string[] = Array.isArray(rawReuse)
+    ? rawReuse
+    : typeof rawReuse === "string"
+    ? [rawReuse]
+    : [];
+
+  const featureConfig = {
+    domain,
+    description: args.description || `Feature: ${featureKey}`,
+    allowed_touchpoints: allowedTouchpoints,
+    reuse_symbols: reuseSymbols,
+    input_contract: args.input_contract || {},
+    output_contract: args.output_contract || {},
+  };
+
+  if (!config.features) {
+    config.features = {};
+  }
+  config.features[featureKey] = featureConfig;
+
+  // Record Active Feature Session Lease (.septum/session.json)
+  SessionManager.saveActiveSession(workspaceRoot, {
+    feature_key: featureKey,
+    domain,
+    touchpoints: featureConfig.allowed_touchpoints,
+    locked_at: new Date().toISOString(),
+  });
+
+  let persisted = false;
+  if (args.persist_to_config) {
+    try {
+      const configPath = path.resolve(workspaceRoot, "septum.config.json");
+      let diskConfig: Record<string, unknown> = {};
+      if (fs.existsSync(configPath)) {
+        diskConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+      }
+      if (!diskConfig.features || typeof diskConfig.features !== "object") {
+        diskConfig.features = {};
+      }
+      (diskConfig.features as Record<string, unknown>)[featureKey] = featureConfig;
+      fs.writeFileSync(configPath, JSON.stringify(diskConfig, null, 2), "utf-8");
+      persisted = true;
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`[Septum Warning] Failed to persist feature to septum.config.json: ${msg}`);
+    }
+  }
+
+  return {
+    content: [
+      {
+        type: "text" as const,
+        text: JSON.stringify(
+          {
+            status: "success",
+            message: `Feature '${featureKey}' successfully registered and session lease established.${
+              persisted ? " Persisted to septum.config.json." : ""
+            }`,
+            feature_key: featureKey,
+            feature: featureKey,
+            domain,
+            touchpoints: featureConfig.allowed_touchpoints,
+            reuse_symbols: featureConfig.reuse_symbols,
+            persisted_to_disk: persisted,
+          },
+          null,
+          2
+        ),
+      },
+    ],
+  };
+}

package/src/mcp/tools/trace-vertical-slice.ts

@@ -1,103 +1,74 @@
-import type { ValidatedSeptumConfig } from "../../core/config/schema.ts";
-import type { SeptumRepository } from "../../core/database/repository.ts";
-import { VerticalSliceTracer } from "../../core/resolver/vertical-slice-tracer.ts";
-import type { VerticalSliceTraceResponse } from "../../types/index.ts";
-
-export interface TraceVerticalSliceArgs {
-  query: string;
-}
-
-export function handleTraceVerticalSlice(
-  repo: SeptumRepository,
-  config: ValidatedSeptumConfig,
-  args: TraceVerticalSliceArgs
-) {
-  if (!args.query) {
-    throw new Error(
-      "Missing required argument: 'query' (e.g. 'POST /orders/{id}/status', 'OrderController@updateStatus', or task intent 'Ubah status order di dashboard')"
-    );
-  }
-
-  const workspaceRoot = (config.settings as Record<string, unknown>)?.workspace_root as string || process.cwd();
-  const tracer = new VerticalSliceTracer(repo, workspaceRoot);
-  const result: VerticalSliceTraceResponse = tracer.trace(args.query);
-
-  let formattedText = "";
-
-  if (result.found && result.slice) {
-    const s = result.slice;
-    formattedText = `=== VERTICAL SLICE TRACE ===\n`;
-    formattedText += `Query: ${result.query}\n`;
-    formattedText += `Status: RESOLVED\n\n`;
-
-    formattedText += `• Route:\n`;
-    formattedText += `    Method: ${s.route.method}\n`;
-    formattedText += `    URI:    ${s.route.uri}\n`;
-    if (s.route.name) {
-      formattedText += `    Name:   ${s.route.name}\n`;
-    }
-
-    if (s.request) {
-      formattedText += `\n• Request / Validation:\n`;
-      formattedText += `    Class:  ${s.request.class} (${s.request.file || "inline"})\n`;
-      const ruleKeys = Object.keys(s.request.rules);
-      if (ruleKeys.length > 0) {
-        formattedText += `    Rules:\n`;
-        for (const k of ruleKeys) {
-          formattedText += `      - ${k} => ${s.request.rules[k]}\n`;
-        }
-      }
-    }
-
-    formattedText += `\n• Controller Action:\n`;
-    formattedText += `    Class:  ${s.controller.class}@${s.controller.action}\n`;
-    formattedText += `    File:   ${s.controller.file || "unknown"}:${s.controller.line}\n`;
-
-    if (s.model) {
-      formattedText += `\n• Model:\n`;
-      formattedText += `    Class:  ${s.model.class} (${s.model.file || "unknown"})\n`;
-      if (s.model.fillable && s.model.fillable.length > 0) {
-        formattedText += `    Fillable: [${s.model.fillable.join(", ")}]\n`;
-      }
-      if (s.model.casts && Object.keys(s.model.casts).length > 0) {
-        formattedText += `    Casts:    ${JSON.stringify(s.model.casts)}\n`;
-      }
-    }
-
-    if (s.frontend) {
-      formattedText += `\n• Frontend Target:\n`;
-      formattedText += `    Page:   ${s.frontend.target}\n`;
-      if (s.frontend.props.length > 0) {
-        formattedText += `    Props:  [${s.frontend.props.join(", ")}]\n`;
-      }
-    }
-
-    if (result.alternatives && result.alternatives.length > 0) {
-      formattedText += `\n• Other Matching Slices:\n`;
-      for (const alt of result.alternatives) {
-        formattedText += `    - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}\n`;
-      }
-    }
-  } else {
-    formattedText = `=== VERTICAL SLICE NOT FOUND ===\n`;
-    formattedText += `Query: ${result.query}\n`;
-    formattedText += `Message: ${result.message}\n`;
-
-    if (result.alternatives && result.alternatives.length > 0) {
-      formattedText += `\nAvailable Slices:\n`;
-      for (const alt of result.alternatives) {
-        formattedText += `    - ${alt.method} ${alt.uri} -> ${alt.controller}@${alt.action}\n`;
-      }
-    }
-  }
-
-  return {
-    content: [
-      {
-        type: "text",
-        text: formattedText.trim(),
-      },
-    ],
-    metadata: result,
-  };
-}
+import type { ValidatedSeptumConfig } from "../../core/config/schema.ts";
+import type { SeptumRepository } from "../../core/database/repository.ts";
+import { VerticalSliceTracer } from "../../core/resolver/vertical-slice-tracer.ts";
+import type { VerticalSliceTraceResponse } from "../../types/index.ts";
+
+export interface TraceVerticalSliceArgs {
+  query?: string;
+  symbol?: string;
+  route?: string;
+  max_depth?: number;
+}
+
+export function handleTraceVerticalSlice(
+  repo: SeptumRepository,
+  config: ValidatedSeptumConfig,
+  args: TraceVerticalSliceArgs,
+  workspaceRoot?: string
+) {
+  const query = (
+    args.query ||
+    args.symbol ||
+    args.route ||
+    ""
+  ).toString().trim();
+
+  if (!query) {
+    throw new Error(
+      "Missing required argument: 'query' (e.g. 'POST /orders/{id}/status', 'OrderController@updateStatus', or task intent 'Ubah status order di dashboard')"
+    );
+  }
+
+  const root =
+    workspaceRoot ||
+    ((config.settings as Record<string, unknown>)?.workspace_root as string) ||
+    process.cwd();
+  const tracer = new VerticalSliceTracer(repo, root);
+  const result: VerticalSliceTraceResponse = tracer.trace(query);
+  const chain = result.chain || result.slice || [];
+
+  let summary = "";
+  if (result.found && chain.length > 0) {
+    summary = chain
+      .map((node) => `[${(node.stage || "STAGE").toUpperCase()}] ${node.symbol}`)
+      .join(" ➔ ");
+  } else if (result.found && result.entrypoint) {
+    summary = `[ENTRYPOINT] ${result.entrypoint.method} ${result.entrypoint.uri} ➔ ${result.entrypoint.controller}@${result.entrypoint.action}`;
+  } else {
+    summary = `[NOT FOUND] No vertical slice matching '${query}'`;
+  }
+
+  const payload = {
+    status: result.found ? "success" : "not_found",
+    query,
+    found: result.found,
+    confidence: result.confidence || (result.found ? "exact" : undefined),
+    is_exact_match: result.is_exact_match,
+    architecture_style: result.architecture_style,
+    entrypoint: result.entrypoint || null,
+    chain,
+    alternatives: result.alternatives || [],
+    summary,
+    message: result.message || summary,
+  };
+
+  return {
+    content: [
+      {
+        type: "text" as const,
+        text: JSON.stringify(payload, null, 2),
+      },
+    ],
+    metadata: payload,
+  };
+}