septum 0.1.2 → 0.1.3

package/src/core/parser/extractors/laravel-semantic.ts

@@ -186,33 +186,12 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
   public parseRoutesContent(content: string): ParsedRoute[] {
     const routes: ParsedRoute[] = [];
 
-    // Match Route::(get|post|put|patch|delete)('uri', [Controller::class, 'action'])->name('...')
-    const methodRegex = /Route::(get|post|put|patch|delete|any)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(?:\[\s*([A-Za-z0-9_]+)::class\s*,\s*['"]([A-Za-z0-9_]+)['"]\s*\]|['"]([A-Za-z0-9_]+)@([A-Za-z0-9_]+)['"])\s*\)(?:\s*->\s*name\s*\(\s*['"]([^'"]+)['"]\s*\))?/gi;
-
-    let match;
-    while ((match = methodRegex.exec(content)) !== null) {
-      const httpMethod = match[1];
-      const uri = match[2];
-      const controllerClass = match[3] || match[5];
-      const actionName = match[4] || match[6];
-      const routeName = match[7];
-
-      if (controllerClass && actionName) {
-        routes.push({
-          httpMethod,
-          uri,
-          routeName,
-          controllerClass,
-          actionName,
-        });
-      }
-    }
-
-    // Match Route::resource('orders', OrderController::class)
-    const resourceRegex = /Route::resource\s*\(\s*['"]([^'"]+)['"]\s*,\s*([A-Za-z0-9_]+)::class\s*\)/gi;
-    while ((match = resourceRegex.exec(content)) !== null) {
-      const baseUri = match[1];
-      const controllerClass = match[2];
+    // 1. Process Route::resource
+    const resourceRegex = /Route::resource\s*\(\s*['"]([^'"]+)['"]\s*,\s*([\\A-Za-z0-9_]+)::class\s*\)/gi;
+    let resMatch;
+    while ((resMatch = resourceRegex.exec(content)) !== null) {
+      const baseUri = resMatch[1].replace(/^\//, "");
+      const controllerClass = resMatch[2];
       const resourceActions = [
         { method: "GET", sub: "", action: "index" },
         { method: "GET", sub: "/create", action: "create" },
@@ -234,9 +213,189 @@ export class LaravelSemanticExtractor implements SemanticSliceExtractor {
       }
     }
 
+    // 2. Parse routes with group context tracking (prefix, controller, name prefix)
+    const lines = content.split(/\r?\n/);
+    interface GroupContext {
+      prefix: string;
+      controller: string;
+      namePrefix: string;
+      braceDepth: number;
+    }
+
+    const groupStack: GroupContext[] = [];
+    let currentBraceDepth = 0;
+    let statementBuffer = "";
+    let inStatement = false;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check group opens: Route::...group(
+      if (trimmed.includes("Route::") && trimmed.includes("group(") && trimmed.includes("function")) {
+        const prefixMatch = /prefix\s*\(\s*['"]([^'"]+)['"]\s*\)/.exec(trimmed);
+        const controllerMatch = /controller\s*\(\s*([\\A-Za-z0-9_]+)::class\s*\)/.exec(trimmed);
+        const nameMatch = /name\s*\(\s*['"]([^'"]+)['"]\s*\)/.exec(trimmed);
+
+        const currentCtx = groupStack[groupStack.length - 1];
+        const newPrefix = [currentCtx?.prefix, prefixMatch ? prefixMatch[1] : ""]
+          .filter(Boolean)
+          .join("/");
+        const newController = controllerMatch ? controllerMatch[1] : (currentCtx?.controller || "");
+        const newNamePrefix = [currentCtx?.namePrefix, nameMatch ? nameMatch[1] : ""]
+          .filter(Boolean)
+          .join("");
+
+        groupStack.push({
+          prefix: newPrefix,
+          controller: newController,
+          namePrefix: newNamePrefix,
+          braceDepth: currentBraceDepth,
+        });
+      }
+
+      // Track brace depth
+      for (const char of line) {
+        if (char === "{") currentBraceDepth++;
+        if (char === "}") {
+          currentBraceDepth--;
+          if (groupStack.length > 0) {
+            const top = groupStack[groupStack.length - 1];
+            if (currentBraceDepth <= top.braceDepth) {
+              groupStack.pop();
+            }
+          }
+        }
+      }
+
+      // Route statement accumulation across lines
+      if (!inStatement && trimmed.startsWith("Route::") && !trimmed.includes("Route::resource") && !trimmed.includes("Route::group")) {
+        statementBuffer = trimmed;
+        inStatement = true;
+      } else if (inStatement) {
+        statementBuffer += " " + trimmed;
+      }
+
+      if (inStatement && statementBuffer.includes(";")) {
+        inStatement = false;
+        const stmt = statementBuffer;
+        statementBuffer = "";
+
+        const currentCtx = groupStack[groupStack.length - 1];
+        const parsed = this.parseSingleRouteStatement(stmt, currentCtx);
+        if (parsed) {
+          routes.push(parsed);
+        }
+      }
+    }
+
     return routes;
   }
 
+  private parseSingleRouteStatement(
+    stmt: string,
+    ctx?: { prefix: string; controller: string; namePrefix: string }
+  ): ParsedRoute | null {
+    const methodMatch = /Route::(get|post|put|patch|delete|any|options)\s*\(\s*['"]([^'"]+)['"]([\s\S]*)/i.exec(stmt);
+    if (!methodMatch) {
+      const viewMatch = /Route::view\s*\(\s*['"]([^'"]+)['"]\s*,\s*['"]([^'"]+)['"]/i.exec(stmt);
+      if (viewMatch) {
+        const rawUri = viewMatch[1];
+        const viewTarget = viewMatch[2];
+        const nameMatch = /->name\s*\(\s*['"]([^'"]+)['"]\s*\)/i.exec(stmt);
+        const fullUri = ctx?.prefix ? `/${ctx.prefix.replace(/^\/|\/$/g, "")}/${rawUri.replace(/^\//, "")}` : rawUri;
+        return {
+          httpMethod: "GET",
+          uri: fullUri.startsWith("/") ? fullUri : `/${fullUri}`,
+          routeName: (ctx?.namePrefix || "") + (nameMatch ? nameMatch[1] : ""),
+          controllerClass: "View",
+          actionName: viewTarget,
+        };
+      }
+      return null;
+    }
+
+    const httpMethod = methodMatch[1].toUpperCase();
+    let uri = methodMatch[2];
+    const rest = methodMatch[3];
+
+    if (ctx?.prefix) {
+      const cleanPrefix = ctx.prefix.replace(/^\/|\/$/g, "");
+      const cleanUri = uri.replace(/^\//, "");
+      uri = cleanUri ? `/${cleanPrefix}/${cleanUri}` : `/${cleanPrefix}`;
+    }
+    if (!uri.startsWith("/")) uri = `/${uri}`;
+
+    const nameMatch = /->name\s*\(\s*['"]([^'"]+)['"]\s*\)/i.exec(stmt);
+    const rawRouteName = nameMatch ? nameMatch[1] : undefined;
+    const fullRouteName = rawRouteName
+      ? (ctx?.namePrefix || "") + rawRouteName
+      : undefined;
+
+    // [Controller::class, 'action']
+    const arrayMatch = /\[\s*([\\A-Za-z0-9_]+)::class\s*,\s*['"]([A-Za-z0-9_]+)['"]\s*\]/.exec(rest);
+    if (arrayMatch) {
+      return {
+        httpMethod,
+        uri,
+        routeName: fullRouteName,
+        controllerClass: arrayMatch[1],
+        actionName: arrayMatch[2],
+      };
+    }
+
+    // 'Controller@action'
+    const stringActionMatch = /['"]([\\A-Za-z0-9_]+)@([A-Za-z0-9_]+)['"]/.exec(rest);
+    if (stringActionMatch) {
+      return {
+        httpMethod,
+        uri,
+        routeName: fullRouteName,
+        controllerClass: stringActionMatch[1],
+        actionName: stringActionMatch[2],
+      };
+    }
+
+    // Action inside controller group
+    if (ctx?.controller) {
+      const singleActionMatch = /,\s*['"]([A-Za-z0-9_]+)['"]/.exec(rest);
+      if (singleActionMatch) {
+        return {
+          httpMethod,
+          uri,
+          routeName: fullRouteName,
+          controllerClass: ctx.controller,
+          actionName: singleActionMatch[1],
+        };
+      }
+    }
+
+    // Invokable controller
+    const invokableMatch = /,\s*([\\A-Za-z0-9_]+)::class/.exec(rest);
+    if (invokableMatch) {
+      return {
+        httpMethod,
+        uri,
+        routeName: fullRouteName,
+        controllerClass: invokableMatch[1],
+        actionName: "__invoke",
+      };
+    }
+
+    // Closure
+    if (rest.includes("function")) {
+      return {
+        httpMethod,
+        uri,
+        routeName: fullRouteName,
+        controllerClass: "Closure",
+        actionName: "handle",
+      };
+    }
+
+    return null;
+  }
+
   private resolveController(controllerClass: string, actionName: string): { filePath?: string; line: number } {
     const simpleName = controllerClass.split(/\\|\//).pop() || controllerClass;
     const candidates = [

package/src/core/parser/extractors/registry.ts

@@ -46,4 +46,25 @@ export class SemanticSliceExtractorRegistry {
 
     return combinedSlices;
   }
+
+  /**
+   * Synchronous execution of all matched semantic extractors.
+   */
+  public static extractAllSlicesSync(
+    projectRoot: string,
+    framework?: string,
+    domainId?: number
+  ): VerticalSliceCandidate[] {
+    const matched = this.getExtractors(projectRoot, framework);
+    const combinedSlices: VerticalSliceCandidate[] = [];
+
+    for (const extractor of matched) {
+      const res = extractor.extractSlices(projectRoot, domainId);
+      if (Array.isArray(res)) {
+        combinedSlices.push(...res);
+      }
+    }
+
+    return combinedSlices;
+  }
 }

package/src/core/parser/tree-sitter.ts

@@ -1,5 +1,6 @@
 import type { ParsedFileAST } from "../../types/index.ts";
 import type { CodeExtractor } from "./extractors/base.ts";
+import { BladeExtractor } from "./extractors/blade.ts";
 import { FrontendExtractor } from "./extractors/frontend.ts";
 import { GoExtractor } from "./extractors/go.ts";
 import { PHPExtractor } from "./extractors/php.ts";
@@ -11,6 +12,7 @@ export class ASTParserEngine {
 
   constructor() {
     this.extractors = [
+      new BladeExtractor(),
       new FrontendExtractor(),
       new TypeScriptExtractor(),
       new PHPExtractor(),

package/src/core/resolver/path-resolver.ts

@@ -0,0 +1,147 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+
+export const PROJECT_ROOT_MARKERS = [
+  "package.json",
+  "composer.json",
+  "go.mod",
+  "pyproject.toml",
+  "Cargo.toml",
+  ".git",
+  ".septum",
+  "pnpm-workspace.yaml",
+  "lerna.json",
+  "tsconfig.json",
+  "jsconfig.json",
+];
+
+let lastKnownProjectRoot: string | undefined;
+
+/**
+ * Normalizes and canonicalizes a path for cross-platform consistency.
+ * On Windows, uppercases drive letters (e.g. "c:\" -> "C:\") to eliminate map lookup misses.
+ */
+export function canonicalizePath(targetPath: string): string {
+  if (!targetPath || typeof targetPath !== "string") {
+    return targetPath;
+  }
+  let abs = normalize(resolve(targetPath));
+  if (process.platform === "win32") {
+    abs = abs.replace(/^[a-zA-Z]:/, (m) => m.toUpperCase());
+  }
+  return abs;
+}
+
+export function setLastKnownProjectRoot(root: string): void {
+  if (root && typeof root === "string") {
+    lastKnownProjectRoot = canonicalizePath(root);
+  }
+}
+
+export function getLastKnownProjectRoot(): string | undefined {
+  return lastKnownProjectRoot;
+}
+
+export function clearLastKnownProjectRoot(): void {
+  lastKnownProjectRoot = undefined;
+}
+
+/**
+ * Checks whether a given directory is an MCP host / IDE installation directory
+ * (e.g. Antigravity Electron install directory) rather than a user project codebase.
+ */
+export function isAppHostDirectory(dirPath: string): boolean {
+  try {
+    const norm = dirPath.toLowerCase().replace(/\\/g, "/");
+    if (norm.includes("/antigravity") || norm.includes("/appdata/local/programs/antigravity")) {
+      // Check if it has Electron app runtime signatures
+      if (
+        existsSync(join(dirPath, "resources", "app.asar")) ||
+        existsSync(join(dirPath, "resources", "app.asar.unpacked")) ||
+        existsSync(join(dirPath, "locales"))
+      ) {
+        return true;
+      }
+    }
+  } catch {
+    // Ignore error
+  }
+  return false;
+}
+
+/**
+ * Discovers the project root directory by walking up looking for marker files.
+ */
+export function findProjectRoot(fromPath: string): string {
+  try {
+    let dir = resolve(fromPath);
+
+    if (existsSync(dir)) {
+      const stat = statSync(dir);
+      if (!stat.isDirectory()) {
+        dir = dirname(dir);
+      }
+    } else {
+      dir = dirname(dir);
+    }
+
+    let current = dir;
+    while (true) {
+      // Don't treat an app host directory as a project root
+      if (!isAppHostDirectory(current)) {
+        for (const marker of PROJECT_ROOT_MARKERS) {
+          if (existsSync(join(current, marker))) {
+            return canonicalizePath(current);
+          }
+        }
+      }
+
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  } catch {
+    // Filesystem traversal error fallback
+  }
+
+  return canonicalizePath(dirname(resolve(fromPath)));
+}
+
+/**
+ * Ergonomically resolves the active workspace root:
+ * 1. Explicit pathHint (if provided and valid).
+ * 2. SEPTUM_WORKSPACE_ROOT environment variable.
+ * 3. lastKnownProjectRoot (if cached from earlier tool calls).
+ * 4. findProjectRoot from process.cwd() (if not an app host directory).
+ */
+export function resolveWorkspaceRoot(pathHint?: string): string {
+  if (pathHint && typeof pathHint === "string" && pathHint.trim()) {
+    const trimmed = pathHint.trim().replace(/^['"]|['"]$/g, "");
+    const candidate = findProjectRoot(trimmed);
+    if (candidate && existsSync(candidate) && !isAppHostDirectory(candidate)) {
+      setLastKnownProjectRoot(candidate);
+      return candidate;
+    }
+  }
+
+  const envRoot = process.env.SEPTUM_WORKSPACE_ROOT || process.env.WORKSPACE_ROOT;
+  if (envRoot && existsSync(envRoot) && !isAppHostDirectory(envRoot)) {
+    const candidate = canonicalizePath(envRoot);
+    setLastKnownProjectRoot(candidate);
+    return candidate;
+  }
+
+  if (lastKnownProjectRoot && existsSync(lastKnownProjectRoot)) {
+    return lastKnownProjectRoot;
+  }
+
+  const cwd = process.cwd();
+  if (!isAppHostDirectory(cwd)) {
+    const candidate = findProjectRoot(cwd);
+    setLastKnownProjectRoot(candidate);
+    return candidate;
+  }
+
+  // Fallback if inside app host directory: keep looking in lastKnown or return cwd
+  return canonicalizePath(cwd);
+}

package/src/core/resolver/vertical-slice-tracer.ts

@@ -5,9 +5,11 @@ import type {
 } from "../../types/index.ts";
 import type { SeptumRepository } from "../database/repository.ts";
 import { CallGraphTracer } from "./call-graph-tracer.ts";
+import { SemanticSliceExtractorRegistry } from "../parser/extractors/registry.ts";
+import { TopologyDetector } from "../discovery/topology-detector.ts";
 
 export class VerticalSliceTracer {
-  constructor(private repo: SeptumRepository) {}
+  constructor(private repo: SeptumRepository, private projectRoot: string = process.cwd()) {}
 
   /**
    * Trace an end-to-end vertical slice from route/action/intent query.
@@ -25,16 +27,29 @@ export class VerticalSliceTracer {
     const lowerTrimmed = trimmed.toLowerCase();
     let allSlices = this.repo.getAllVerticalSlices();
 
-    // Lazy fallback: If no slices cataloged, attempt heuristic call-graph tracing
-    if (allSlices.length === 0) {
+    // Lazy on-demand fallback: If no slices cataloged, extract framework routes or trace call-graph
+    const hasCatalogData = typeof (this.repo as any).getAllDomains === "function" && this.repo.getAllDomains().length > 0;
+    if (allSlices.length === 0 && hasCatalogData) {
       try {
-        const tracer = new CallGraphTracer(this.repo);
-        const traced = tracer.traceAllSlices();
-        if (traced.length > 0) {
-          for (const s of traced) {
+        const topology = TopologyDetector.detect(this.projectRoot);
+        const semanticSlices = SemanticSliceExtractorRegistry.extractAllSlicesSync(
+          this.projectRoot,
+          topology.framework
+        );
+        if (semanticSlices.length > 0) {
+          for (const s of semanticSlices) {
             this.repo.upsertVerticalSlice(s);
           }
           allSlices = this.repo.getAllVerticalSlices();
+        } else {
+          const tracer = new CallGraphTracer(this.repo, this.projectRoot);
+          const traced = tracer.traceAllSlices();
+          if (traced.length > 0) {
+            for (const s of traced) {
+              this.repo.upsertVerticalSlice(s);
+            }
+            allSlices = this.repo.getAllVerticalSlices();
+          }
         }
       } catch (err: unknown) {
         const msg = err instanceof Error ? err.message : String(err);