codesift-mcp 0.5.28 → 0.5.30

package/dist/register-tools.js

@@ -1,3 +1,4 @@
+import * as pathModule from "node:path";
 import { z } from "zod";
 /** Boolean that also accepts "true"/"false" strings (LLMs often send strings instead of booleans) */
 const zBool = () => z.union([z.boolean(), z.string().transform((s) => s === "true")]).optional();
@@ -207,6 +208,16 @@ const FRAMEWORK_TOOL_GROUPS = {
         "resolve_php_service",
         "php_security_scan",
         "php_project_audit",
+        // PHP stacks (Yii2/Laravel/Symfony) overwhelmingly run on MySQL/Postgres with
+        // raw .sql migrations and ActiveRecord models. The SQL toolchain is the
+        // missing entry-point for schema/drift/lint/dml work — auto-revealing it
+        // here closes the gap that 0 SQL tools have ever been called from PHP repos.
+        "analyze_schema",
+        "trace_query",
+        "sql_audit",
+        "diff_migrations",
+        "search_columns",
+        "migration_lint",
     ],
     // Kotlin / Android / Gradle — detected by build.gradle.kts or settings.gradle.kts
     "build.gradle.kts": [
@@ -363,6 +374,20 @@ const PRISMA_TOOLS = [
     "analyze_prisma_schema",
     "migration_lint",
 ];
+/**
+ * Raw-SQL toolchain — auto-enabled when a project has loose `*.sql` files
+ * (migrations, seeds, mysqldump). Independent of any ORM. Targets the
+ * "PHP/Yii2 + MySQL legacy" segment that historically called 0 of these
+ * tools because they were hidden behind discover_tools.
+ */
+const SQL_TOOLS = [
+    "analyze_schema",
+    "trace_query",
+    "sql_audit",
+    "diff_migrations",
+    "search_columns",
+    "migration_lint",
+];
 const AUTO_LOAD_CACHE_TTL_MS = 5_000;
 const autoLoadToolsCache = new Map();
 /**
@@ -386,14 +411,36 @@ export async function detectAutoLoadTools(cwd) {
     if (existsSync(join(cwd, "prisma", "schema.prisma"))) {
         toEnable.push(...PRISMA_TOOLS);
     }
+    // Raw SQL detection — fires on any project with loose `*.sql` files in
+    // common schema/migration dirs. Catches mysqldump/pg_dump artifacts and
+    // hand-written migrations across PHP/Python/Go/Java stacks regardless of
+    // ORM. Composer-based PHP repos already pull SQL_TOOLS via FRAMEWORK_TOOL_GROUPS;
+    // this branch covers everything else (e.g. Django + raw migrations,
+    // standalone schema repos).
+    if (hasSqlFilesShallow(cwd, readdirSync)) {
+        toEnable.push(...SQL_TOOLS);
+    }
     const detectFromPackageJson = (pkgRoot) => {
         const enabled = [];
         const pkgPath = join(pkgRoot, "package.json");
         if (!existsSync(pkgPath))
             return enabled;
+        let pkg;
         try {
-            const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        }
+        catch {
+            /* malformed or unreadable package.json — omit silently */
+            return enabled;
+        }
+        if (!pkg || typeof pkg !== "object" || Array.isArray(pkg))
+            return enabled;
+        try {
+            const manifest = pkg;
+            const allDeps = {
+                ...manifest.dependencies,
+                ...manifest.devDependencies,
+            };
             const hasReact = !!(allDeps["react"] ||
                 allDeps["next"] ||
                 allDeps["@remix-run/react"] ||
@@ -422,14 +469,18 @@ export async function detectAutoLoadTools(cwd) {
             // npm/yarn/pnpm workspaces field — content-based monorepo signal.
             // Complements the file-based signals (pnpm-workspace.yaml, lerna.json,
             // nx.json, turbo.json) so plain `"workspaces": [...]` setups also fire.
-            const hasWorkspaces = Array.isArray(pkg.workspaces) ||
-                (pkg.workspaces && typeof pkg.workspaces === "object" &&
-                    Array.isArray(pkg.workspaces.packages));
+            const ws = manifest.workspaces;
+            const hasWorkspaces = Array.isArray(ws) ||
+                (ws !== null &&
+                    typeof ws === "object" &&
+                    !Array.isArray(ws) &&
+                    Array.isArray(ws.packages));
             if (hasWorkspaces)
                 enabled.push(...MONOREPO_TOOLS);
         }
-        catch {
-            /* malformed package.json */
+        catch (err) {
+            const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+            console.warn(`[codesift-mcp] detectFromPackageJson(${pkgRoot}): ${detail}`);
         }
         return enabled;
     };
@@ -481,7 +532,8 @@ export function detectAutoLoadToolsCached(cwd) {
  * Skips node_modules, dist, build, .next, .astro, .git.
  */
 function hasJsxFilesShallow(cwd, readdirSyncFn) {
-    const { join } = require("node:path");
+    // ESM-safe path import (avoid `require("node:path")`, which throws under ESM).
+    const { join } = pathModule;
     const IGNORE = new Set([
         "node_modules", "dist", "build", ".next", ".astro", ".git",
         "out", "coverage", ".turbo", ".vercel", ".cache",
@@ -519,6 +571,65 @@ function hasJsxFilesShallow(cwd, readdirSyncFn) {
     }
     return false;
 }
+/**
+ * Quick scan for *.sql files in conventional schema/migration directories.
+ * Used to auto-enable the SQL toolchain on any project that ships raw SQL
+ * regardless of language stack. Stops on first hit; depth capped at 3 so
+ * nested package dirs (e.g. monorepo apps/*) are still reachable.
+ */
+function hasSqlFilesShallow(cwd, readdirSyncFn) {
+    const { join } = pathModule;
+    const IGNORE = new Set([
+        "node_modules", "dist", "build", ".next", ".astro", ".git",
+        "out", "coverage", ".turbo", ".vercel", ".cache", "vendor",
+    ]);
+    // SQL conventionally lives in dedicated dirs — scanning every src/ tree
+    // would trigger false positives on test fixtures and string-literal SQL.
+    const DEEP_ROOTS = [
+        "migrations", "migration", "db", "database", "schema", "schemas",
+        "sql", "ddl", "seeds", "seed", "supabase",
+        "prisma/migrations", "drizzle/migrations",
+    ];
+    function scanDeep(dir, depth) {
+        if (depth > 3)
+            return false;
+        let entries;
+        try {
+            entries = readdirSyncFn(dir, { withFileTypes: true });
+        }
+        catch {
+            return false;
+        }
+        for (const e of entries) {
+            if (e.isFile() && /\.sql$/i.test(e.name))
+                return true;
+        }
+        for (const e of entries) {
+            if (e.isDirectory() && !IGNORE.has(e.name) && !e.name.startsWith(".")) {
+                if (scanDeep(join(dir, e.name), depth + 1))
+                    return true;
+            }
+        }
+        return false;
+    }
+    // Top-level: dump files like `schema.sql` / `init.sql` / `database.sql`.
+    try {
+        const rootEntries = readdirSyncFn(cwd, { withFileTypes: true });
+        for (const e of rootEntries) {
+            if (e.isFile() && /\.sql$/i.test(e.name))
+                return true;
+        }
+    }
+    catch { /* skip */ }
+    for (const root of DEEP_ROOTS) {
+        try {
+            if (scanDeep(join(cwd, root), 0))
+                return true;
+        }
+        catch { /* skip */ }
+    }
+    return false;
+}
 // ---------------------------------------------------------------------------
 // Output schemas — typed results for structured validation & documentation
 // ---------------------------------------------------------------------------
@@ -3701,13 +3812,14 @@ const TOOL_DEFINITIONS = [
     {
         name: "analyze_schema",
         category: "analysis",
-        searchHint: "SQL schema ERD entity relationship tables views columns foreign key database migration",
-        description: "Analyze SQL schema: tables, views, columns, foreign keys, relationships. Output as JSON or Mermaid ERD.",
+        searchHint: "SQL schema ERD entity relationship tables views columns foreign key database migration MySQL Postgres SQLite dialect",
+        description: "Analyze SQL schema: tables, views, columns, foreign keys, relationships. Auto-detects dialect (mysql/postgres/sqlite/mssql) from schema fingerprints. Output as JSON or Mermaid ERD.",
         schema: lazySchema(() => ({
             repo: z.string().optional().describe("Repository identifier (default: auto-detected from CWD)"),
             file_pattern: z.string().optional().describe("Filter SQL files by pattern (e.g. 'migrations/')"),
             output_format: z.enum(["json", "mermaid"]).optional().describe("Output format (default: json)"),
             include_columns: zBool().describe("Include column details in output (default: true)"),
+            dialect: z.enum(["auto", "mysql", "postgres", "sqlite", "mssql", "unknown"]).optional().describe("Force dialect, or 'auto' to detect from ENGINE=InnoDB / SERIAL / AUTOINCREMENT etc. (default: auto)"),
         })),
         handler: async (args) => {
             const { analyzeSchema } = await import("./tools/sql-tools.js");
@@ -3718,9 +3830,11 @@ const TOOL_DEFINITIONS = [
                 opts.output_format = args.output_format;
             if (args.include_columns != null)
                 opts.include_columns = args.include_columns;
+            if (args.dialect != null)
+                opts.dialect = args.dialect;
             const result = await analyzeSchema(args.repo, opts);
             const parts = [];
-            parts.push(`Tables: ${result.tables.length} | Views: ${result.views.length} | Relationships: ${result.relationships.length}`);
+            parts.push(`Tables: ${result.tables.length} | Views: ${result.views.length} | Relationships: ${result.relationships.length} | Dialect: ${result.detected_dialect}`);
             if (result.warnings.length > 0)
                 parts.push(`Warnings: ${result.warnings.join("; ")}`);
             if (result.mermaid) {