septum 0.1.1 → 0.1.3

package/src/core/resolver/symbol-locator.ts

@@ -148,12 +148,109 @@ export class SymbolLocator {
     const containers = this.repo.findContainers(simpleContainerName);
 
     if (containers.length === 0) {
+      // Container not found directly: search for fuzzy container matches across the catalog
+      const allSymbols = this.repo.getAllSymbolsWithFiles();
+      const containerCandidates = allSymbols.filter((s) =>
+        ["class", "interface", "trait", "enum", "struct"].includes(s.kind)
+      );
+
+      // Score containers by similarity
+      const scoredContainers = containerCandidates
+        .map((s) => {
+          const bare = s.name.includes("::")
+            ? s.name.split("::")[0]
+            : s.name.split(/\\|\//).pop() || s.name;
+          const score = calculateSimilarity(simpleContainerName, bare);
+          return {
+            name: s.name,
+            bare,
+            kind: s.kind,
+            signature: s.signature,
+            line_start: s.line_start,
+            line_end: s.line_end,
+            file_path: s.file_path,
+            similarity_score: Math.round(score * 100) / 100,
+          };
+        })
+        .filter((c) => c.similarity_score >= 0.3)
+        .sort((a, b) => b.similarity_score - a.similarity_score);
+
+      // Deduplicate by name + file_path
+      const seenContainers = new Set<string>();
+      const uniqueContainers = scoredContainers.filter((c) => {
+        const key = `${c.name}@${c.file_path}`;
+        if (seenContainers.has(key)) return false;
+        seenContainers.add(key);
+        return true;
+      }).slice(0, 5);
+
+      // If a member was requested, prioritize methods within top fuzzy candidate containers
+      let memberSuggestions: SuggestionMatch[] = [];
+      if (memberName) {
+        const topCandidateFilePaths = new Set(uniqueContainers.map((c) => c.file_path));
+
+        const candidateMethods = allSymbols.filter(
+          (s) =>
+            (s.kind === "method" || s.kind === "function") &&
+            topCandidateFilePaths.has(s.file_path)
+        );
+
+        const methodsToScore =
+          candidateMethods.length > 0
+            ? candidateMethods
+            : allSymbols
+                .filter(
+                  (s) =>
+                    (s.kind === "method" || s.kind === "function") &&
+                    Math.abs(s.name.length - memberName.length) <= 8
+                )
+                .slice(0, 100);
+
+        memberSuggestions = methodsToScore
+          .map((s) => {
+            const bare = s.name.includes("::") ? s.name.split("::")[1] : s.name;
+            const score = calculateSimilarity(memberName, bare);
+            return {
+              name: s.name,
+              kind: s.kind,
+              signature: `${s.signature} (${s.file_path}:${s.line_start})`,
+              line_start: s.line_start,
+              line_end: s.line_end,
+              similarity_score: Math.round(score * 100) / 100,
+              file_path: s.file_path,
+            };
+          })
+          .filter((s) => s.similarity_score >= 0.35)
+          .sort((a, b) => b.similarity_score - a.similarity_score)
+          .slice(0, 5);
+      }
+
+      const suggestions: SuggestionMatch[] = uniqueContainers.map((c) => ({
+        name: c.name,
+        kind: c.kind,
+        signature: `${c.signature || c.kind} (${c.file_path}:${c.line_start})`,
+        line_start: c.line_start,
+        line_end: c.line_end,
+        similarity_score: c.similarity_score,
+        file_path: c.file_path,
+      }));
+
+      // Combine container suggestions with member suggestions if available
+      const combinedSuggestions = [...suggestions, ...memberSuggestions]
+        .sort((a, b) => b.similarity_score - a.similarity_score)
+        .slice(0, 7);
+
+      const topSuggestion = combinedSuggestions.length > 0 ? combinedSuggestions[0].name : null;
+      const hint = topSuggestion
+        ? ` Container '${containerQuery}' was not found. Did you mean '${topSuggestion}'?`
+        : ` Container '${containerQuery}' was not found in cataloged files.`;
+
       return {
         query: parsed.raw,
         parsed,
         found: false,
-        suggestions: [],
-        message: `Container '${containerQuery}' was not found in any cataloged files. Run 'septum ingest' if recently added.`,
+        suggestions: combinedSuggestions,
+        message: `${hint} Run 'septum ingest' if this file was recently added.`,
       };
     }
 
@@ -327,7 +424,9 @@ export class SymbolLocator {
     const suggestions: SuggestionMatch[] = allSymbols
       .map((s) => {
         const bareName = s.name.includes("::") ? s.name.split("::")[1] : s.name;
-        const score = calculateSimilarity(targetName, bareName);
+        const scoreBare = calculateSimilarity(targetName, bareName);
+        const scoreFull = calculateSimilarity(targetName, s.name);
+        const score = Math.max(scoreBare, scoreFull);
         return {
           name: s.name,
           kind: s.kind,
@@ -335,9 +434,10 @@ export class SymbolLocator {
           line_start: s.line_start,
           line_end: s.line_end,
           similarity_score: Math.round(score * 100) / 100,
+          file_path: s.file_path,
         };
       })
-      .filter((s) => s.similarity_score >= 0.35)
+      .filter((s) => s.similarity_score >= 0.3)
       .sort((a, b) => b.similarity_score - a.similarity_score)
       .slice(0, 5);
 
@@ -352,7 +452,9 @@ export class SymbolLocator {
 }
 
 /**
- * Standard Levenshtein distance with token substring bonus.
+ * Enhanced similarity matching:
+ * Combines Damerau-Levenshtein distance (handling typos & transpositions),
+ * prefix/suffix matching, substring inclusion, and token Jaccard similarity.
  */
 export function calculateSimilarity(source: string, target: string): number {
   const s1 = source.toLowerCase();
@@ -361,20 +463,43 @@ export function calculateSimilarity(source: string, target: string): number {
   if (s1 === s2) return 1.0;
   if (!s1 || !s2) return 0.0;
 
+  // Prefix bonus: highly relevant for autocomplete-style / partial searches
+  let prefixBonus = 0;
+  if (s2.startsWith(s1) || s1.startsWith(s2)) {
+    const minLen = Math.min(s1.length, s2.length);
+    const maxLen = Math.max(s1.length, s2.length);
+    prefixBonus = 0.25 * (minLen / maxLen);
+  }
+
   // Substring inclusion bonus
+  let substringBonus = 0;
   if (s2.includes(s1) || s1.includes(s2)) {
     const minLen = Math.min(s1.length, s2.length);
     const maxLen = Math.max(s1.length, s2.length);
-    return 0.5 + 0.5 * (minLen / maxLen);
+    substringBonus = 0.3 * (minLen / maxLen);
   }
 
-  // Token-based matching (e.g. calculateTotal vs recalculateOrder shares 'calculate')
-  const tokenize = (str: string) => str.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_-]+/);
-  const t1 = tokenize(s1);
-  const t2 = tokenize(s2);
-  const sharedTokens = t1.filter((token) => t2.some((t) => t.includes(token) || token.includes(t)));
-  const tokenBonus = sharedTokens.length > 0 ? 0.3 : 0.0;
+  // Token-based matching (CamelCase, snake_case, kebab-case, namespaces)
+  const tokenize = (str: string) =>
+    str
+      .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+      .toLowerCase()
+      .split(/[\s_\-\.\:\/\\]+/)
+      .filter((t) => t.length > 1);
+
+  const t1 = tokenize(source);
+  const t2 = tokenize(target);
+  let tokenBonus = 0;
+  if (t1.length > 0 && t2.length > 0) {
+    const sharedTokens = t1.filter((token) =>
+      t2.some((t) => t.includes(token) || token.includes(t))
+    );
+    const allUniqueTokens = new Set([...t1, ...t2]);
+    const jaccard = sharedTokens.length / (allUniqueTokens.size || 1);
+    tokenBonus = jaccard * 0.35;
+  }
 
+  // Damerau-Levenshtein Matrix
   const len1 = s1.length;
   const len2 = s2.length;
   const matrix: number[][] = [];
@@ -389,11 +514,23 @@ export function calculateSimilarity(source: string, target: string): number {
   for (let i = 1; i <= len1; i++) {
     for (let j = 1; j <= len2; j++) {
       const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(
+      let minCost = Math.min(
         matrix[i - 1][j] + 1, // deletion
         matrix[i][j - 1] + 1, // insertion
         matrix[i - 1][j - 1] + cost // substitution
       );
+
+      // Transposition check (Damerau)
+      if (
+        i > 1 &&
+        j > 1 &&
+        s1[i - 1] === s2[j - 2] &&
+        s1[i - 2] === s2[j - 1]
+      ) {
+        minCost = Math.min(minCost, matrix[i - 2][j - 2] + 1);
+      }
+
+      matrix[i][j] = minCost;
     }
   }
 
@@ -401,5 +538,6 @@ export function calculateSimilarity(source: string, target: string): number {
   const maxLen = Math.max(len1, len2);
   const rawSimilarity = 1.0 - distance / maxLen;
 
-  return Math.min(1.0, Math.max(0.0, rawSimilarity + tokenBonus));
+  const totalScore = rawSimilarity + prefixBonus + substringBonus + tokenBonus;
+  return Math.min(1.0, Math.max(0.0, totalScore));
 }

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

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>;