septum 0.1.1 → 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/module-resolver.ts

@@ -201,23 +201,42 @@ export class ModuleResolver {
     return null;
   }
 
+  public toCanonicalPath(filePath: string): string {
+    let resolved = path.isAbsolute(filePath)
+      ? path.normalize(filePath)
+      : path.resolve(this.projectRoot, filePath);
+
+    if (process.platform === "win32") {
+      // Normalize drive letter to uppercase (e.g. c:\ -> C:\)
+      resolved = resolved.replace(/^[a-zA-Z]:/, (m) => m.toUpperCase());
+    }
+    return resolved;
+  }
+
   private isSubPathOrSame(targetPath: string, rootPath: string): boolean {
-    const normalizedTarget = path.normalize(targetPath);
-    const normalizedRoot = path.normalize(rootPath);
+    const canonicalTarget = this.toCanonicalPath(targetPath);
+    const canonicalRoot = this.toCanonicalPath(rootPath);
+
+    if (process.platform === "win32") {
+      const lowerTarget = canonicalTarget.toLowerCase();
+      const lowerRoot = canonicalRoot.toLowerCase();
+      if (lowerTarget === lowerRoot) return true;
+      const rootWithSep = lowerRoot.endsWith(path.sep)
+        ? lowerRoot
+        : lowerRoot + path.sep;
+      return lowerTarget.startsWith(rootWithSep);
+    }
 
-    if (normalizedTarget === normalizedRoot) return true;
-    const rootWithSep = normalizedRoot.endsWith(path.sep)
-      ? normalizedRoot
-      : normalizedRoot + path.sep;
+    if (canonicalTarget === canonicalRoot) return true;
+    const rootWithSep = canonicalRoot.endsWith(path.sep)
+      ? canonicalRoot
+      : canonicalRoot + path.sep;
 
-    return normalizedTarget.startsWith(rootWithSep);
+    return canonicalTarget.startsWith(rootWithSep);
   }
 
   private toAbsolutePath(filePath: string): string {
-    if (path.isAbsolute(filePath)) {
-      return path.normalize(filePath);
-    }
-    return path.resolve(this.projectRoot, filePath);
+    return this.toCanonicalPath(filePath);
   }
 
   private extractSymbolName(target: string): string | null {

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);
+}