codesight 1.0.0

package/dist/detectors/contracts.js

@@ -0,0 +1,118 @@
+import { join } from "node:path";
+import { readFileSafe } from "../scanner.js";
+/**
+ * Enhances route info with request/response type information
+ * by scanning the route handler files for type annotations
+ */
+export async function enrichRouteContracts(routes, project) {
+    // Group routes by file to avoid re-reading
+    const fileCache = new Map();
+    for (const route of routes) {
+        const absPath = join(project.root, route.file);
+        let content = fileCache.get(route.file);
+        if (!content) {
+            content = await readFileSafe(absPath);
+            fileCache.set(route.file, content);
+        }
+        // Extract URL params from path like :id, [id], {id}
+        const params = [];
+        const paramPatterns = [
+            /:(\w+)/g, // Express/Hono style :param
+            /\[(\w+)\]/g, // Next.js style [param]
+            /\{(\w+)\}/g, // FastAPI/Django style {param}
+            /<(\w+)>/g, // Flask style <param>
+        ];
+        for (const pattern of paramPatterns) {
+            let match;
+            while ((match = pattern.exec(route.path)) !== null) {
+                params.push(match[1]);
+            }
+        }
+        if (params.length > 0)
+            route.params = params;
+        // Try to extract response type based on framework
+        switch (route.framework) {
+            case "hono":
+            case "express":
+            case "fastify":
+            case "koa":
+                enrichTSRoute(route, content);
+                break;
+            case "next-app":
+                enrichNextRoute(route, content);
+                break;
+            case "fastapi":
+                enrichFastAPIRoute(route, content);
+                break;
+            case "flask":
+                enrichFlaskRoute(route, content);
+                break;
+        }
+    }
+    return routes;
+}
+function enrichTSRoute(route, content) {
+    // Look for c.json<Type>(...) or res.json({...}) patterns near the route method
+    // Hono: return c.json<ResponseType>(data)
+    const jsonTypeMatch = content.match(/c\.json\s*<\s*([^>]+)\s*>/);
+    if (jsonTypeMatch) {
+        route.responseType = jsonTypeMatch[1].trim();
+        return;
+    }
+    // Look for zod validation schemas: .input(z.object({...})) or validate(schema)
+    const zodInputMatch = content.match(/zValidator\s*\(\s*['"](?:json|form)['"],\s*(\w+)/);
+    if (zodInputMatch) {
+        route.requestType = zodInputMatch[1];
+    }
+    // Look for explicit return type annotations on handler
+    const handlerReturnMatch = content.match(/:\s*Promise\s*<\s*Response\s*<\s*([^>]+)\s*>\s*>/);
+    if (handlerReturnMatch) {
+        route.responseType = handlerReturnMatch[1].trim();
+    }
+}
+function enrichNextRoute(route, content) {
+    // NextResponse.json({ ... }) or Response.json({ ... })
+    const responseMatch = content.match(/(?:NextResponse|Response)\.json\s*\(\s*\{([^}]{1,200})\}/);
+    if (responseMatch) {
+        // Extract key names from the response object
+        const keys = responseMatch[1]
+            .split(",")
+            .map((s) => s.trim().split(/[:\s]/)[0])
+            .filter(Boolean);
+        if (keys.length > 0 && keys.length <= 8) {
+            route.responseType = `{ ${keys.join(", ")} }`;
+        }
+    }
+}
+function enrichFastAPIRoute(route, content) {
+    // @app.get("/path", response_model=SchemaName)
+    const responseModelMatch = content.match(new RegExp(`response_model\\s*=\\s*(\\w+)`));
+    if (responseModelMatch) {
+        route.responseType = responseModelMatch[1];
+    }
+    // Find the handler function after the decorator and check for Pydantic param types
+    // def handler(item: ItemCreate, db: Session = Depends(...))
+    const funcPattern = new RegExp(`@\\w+\\.${route.method.toLowerCase()}\\s*\\([^)]*\\)\\s*\\n\\s*(?:async\\s+)?def\\s+\\w+\\s*\\(([^)]+)\\)`);
+    const funcMatch = content.match(funcPattern);
+    if (funcMatch) {
+        const params = funcMatch[1];
+        // Find non-dependency params with type hints (skip Depends, Query, etc.)
+        const bodyParam = params.match(/(\w+)\s*:\s*(\w+)(?!\s*=\s*(?:Depends|Query|Path|Header))/);
+        if (bodyParam && !["Session", "Request", "Response", "str", "int", "float", "bool"].includes(bodyParam[2])) {
+            route.requestType = bodyParam[2];
+        }
+    }
+}
+function enrichFlaskRoute(route, content) {
+    // Look for jsonify({ ... }) or return {"key": ...}
+    const jsonifyMatch = content.match(/jsonify\s*\(\s*\{([^}]{1,200})\}/);
+    if (jsonifyMatch) {
+        const keys = jsonifyMatch[1]
+            .split(",")
+            .map((s) => s.trim().split(/['":\s]/)[0].replace(/['"]/g, ""))
+            .filter(Boolean);
+        if (keys.length > 0 && keys.length <= 8) {
+            route.responseType = `{ ${keys.join(", ")} }`;
+        }
+    }
+}

package/dist/detectors/graph.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyGraph, ProjectInfo } from "../types.js";
+export declare function detectDependencyGraph(files: string[], project: ProjectInfo): Promise<DependencyGraph>;

package/dist/detectors/graph.js

@@ -0,0 +1,113 @@
+import { relative, dirname, resolve, extname } from "node:path";
+import { readFileSafe } from "../scanner.js";
+export async function detectDependencyGraph(files, project) {
+    const edges = [];
+    const importCount = new Map();
+    const codeFiles = files.filter((f) => f.match(/\.(ts|tsx|js|jsx|mjs|py|go)$/));
+    for (const file of codeFiles) {
+        const content = await readFileSafe(file);
+        if (!content)
+            continue;
+        const rel = relative(project.root, file);
+        const ext = extname(file);
+        if (ext === ".py") {
+            extractPythonImports(content, rel, edges, importCount);
+        }
+        else if (ext === ".go") {
+            extractGoImports(content, rel, edges, importCount);
+        }
+        else {
+            extractTSImports(content, rel, file, project, files, edges, importCount);
+        }
+    }
+    // Sort by most imported
+    const hotFiles = Array.from(importCount.entries())
+        .map(([file, count]) => ({ file, importedBy: count }))
+        .sort((a, b) => b.importedBy - a.importedBy)
+        .slice(0, 20);
+    return { edges, hotFiles };
+}
+function extractTSImports(content, rel, absPath, project, allFiles, edges, importCount) {
+    // Match: import ... from "./path" or import("./path") or require("./path")
+    const patterns = [
+        /(?:import|export)\s+.*?from\s+['"]([^'"]+)['"]/g,
+        /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const importPath = match[1];
+            // Only track local imports (starting with . or @/ alias)
+            if (!importPath.startsWith(".") && !importPath.startsWith("@/") && !importPath.startsWith("~/"))
+                continue;
+            // Resolve to relative path
+            let resolvedPath;
+            if (importPath.startsWith("@/") || importPath.startsWith("~/")) {
+                resolvedPath = importPath.replace(/^[@~]\//, "src/");
+            }
+            else {
+                const dir = dirname(absPath);
+                resolvedPath = relative(project.root, resolve(dir, importPath));
+            }
+            // Strip extension and try to find the actual file
+            const normalized = normalizeImportPath(resolvedPath, allFiles, project.root);
+            if (normalized && normalized !== rel) {
+                edges.push({ from: rel, to: normalized });
+                importCount.set(normalized, (importCount.get(normalized) || 0) + 1);
+            }
+        }
+    }
+}
+function extractPythonImports(content, rel, edges, importCount) {
+    // from .module import something or from ..package.module import something
+    const fromPattern = /^from\s+(\.+\w[\w.]*)\s+import/gm;
+    let match;
+    while ((match = fromPattern.exec(content)) !== null) {
+        const target = match[1].replace(/\./g, "/") + ".py";
+        edges.push({ from: rel, to: target });
+        importCount.set(target, (importCount.get(target) || 0) + 1);
+    }
+}
+function extractGoImports(content, rel, edges, importCount) {
+    // Go doesn't have relative imports in the same way, but we can track internal package imports
+    const importBlock = content.match(/import\s*\(([\s\S]*?)\)/);
+    if (!importBlock)
+        return;
+    // Look for internal package paths (not standard library)
+    const lines = importBlock[1].split("\n");
+    for (const line of lines) {
+        const pathMatch = line.match(/["']([^"']+)["']/);
+        if (pathMatch && pathMatch[1].includes("/") && !pathMatch[1].startsWith("github.com") && !pathMatch[1].includes(".")) {
+            const target = pathMatch[1];
+            edges.push({ from: rel, to: target });
+            importCount.set(target, (importCount.get(target) || 0) + 1);
+        }
+    }
+}
+function normalizeImportPath(importPath, allFiles, root) {
+    // Try exact match first
+    for (const file of allFiles) {
+        const rel = relative(root, file);
+        if (rel === importPath)
+            return rel;
+    }
+    // Try with extensions
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
+    for (const ext of extensions) {
+        for (const file of allFiles) {
+            const rel = relative(root, file);
+            if (rel === importPath + ext)
+                return rel;
+        }
+    }
+    // Try index files
+    for (const ext of extensions) {
+        for (const file of allFiles) {
+            const rel = relative(root, file);
+            if (rel === importPath + "/index" + ext)
+                return rel;
+        }
+    }
+    return null;
+}

package/dist/detectors/libs.d.ts

@@ -0,0 +1,2 @@
+import type { LibExport, ProjectInfo } from "../types.js";
+export declare function detectLibs(files: string[], project: ProjectInfo): Promise<LibExport[]>;

package/dist/detectors/libs.js

@@ -0,0 +1,206 @@
+import { relative, extname } from "node:path";
+import { readFileSafe } from "../scanner.js";
+const SKIP_DIRS = [
+    "/components/",
+    "/pages/",
+    "/app/",
+    "/routes/",
+    "/views/",
+    "/templates/",
+    "/__tests__/",
+    "/__mocks__/",
+    "/test/",
+    "/tests/",
+    "/stories/",
+];
+export async function detectLibs(files, project) {
+    const libFiles = files.filter((f) => {
+        const ext = extname(f);
+        if (![".ts", ".js", ".mjs", ".py", ".go"].includes(ext))
+            return false;
+        if (f.endsWith(".test.ts") || f.endsWith(".spec.ts"))
+            return false;
+        if (f.endsWith(".test.js") || f.endsWith(".spec.js"))
+            return false;
+        if (f.endsWith(".d.ts"))
+            return false;
+        if (f.endsWith("_test.py") || f.endsWith("_test.go"))
+            return false;
+        // Skip component/page/route files
+        if (f.endsWith(".tsx") || f.endsWith(".jsx"))
+            return false;
+        if (SKIP_DIRS.some((d) => f.includes(d)))
+            return false;
+        return true;
+    });
+    const libs = [];
+    for (const file of libFiles) {
+        const content = await readFileSafe(file);
+        if (!content)
+            continue;
+        const rel = relative(project.root, file);
+        const ext = extname(file);
+        let exports;
+        if (ext === ".py") {
+            exports = extractPythonExports(content);
+        }
+        else if (ext === ".go") {
+            exports = extractGoExports(content);
+        }
+        else {
+            exports = extractTSExports(content);
+        }
+        // Only include files with at least one function/class export
+        const hasMeaningful = exports.some((e) => e.kind === "function" || e.kind === "class");
+        if (hasMeaningful && exports.length > 0) {
+            libs.push({ file: rel, exports });
+        }
+    }
+    return libs;
+}
+function extractTSExports(content) {
+    const exports = [];
+    // export function name(params): returnType
+    const fnPattern = /export\s+(?:async\s+)?function\s+(\w+)\s*(?:<[^>]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^\n{]+))?/g;
+    let match;
+    while ((match = fnPattern.exec(content)) !== null) {
+        const params = compactParams(match[2]);
+        const ret = match[3]?.trim() || "void";
+        exports.push({
+            name: match[1],
+            kind: "function",
+            signature: `(${params}) => ${ret}`,
+        });
+    }
+    // export const name = (...) => or export const name = function
+    const constFnPattern = /export\s+const\s+(\w+)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s+)?(?:\([^)]*\)|(\w+))\s*(?::\s*[^=]+)?\s*=>/g;
+    while ((match = constFnPattern.exec(content)) !== null) {
+        exports.push({
+            name: match[1],
+            kind: "function",
+        });
+    }
+    // export class Name
+    const classPattern = /export\s+(?:abstract\s+)?class\s+(\w+)/g;
+    while ((match = classPattern.exec(content)) !== null) {
+        exports.push({ name: match[1], kind: "class" });
+    }
+    // export interface Name
+    const ifacePattern = /export\s+interface\s+(\w+)/g;
+    while ((match = ifacePattern.exec(content)) !== null) {
+        exports.push({ name: match[1], kind: "interface" });
+    }
+    // export type Name
+    const typePattern = /export\s+type\s+(\w+)/g;
+    while ((match = typePattern.exec(content)) !== null) {
+        exports.push({ name: match[1], kind: "type" });
+    }
+    // export enum Name
+    const enumPattern = /export\s+(?:const\s+)?enum\s+(\w+)/g;
+    while ((match = enumPattern.exec(content)) !== null) {
+        exports.push({ name: match[1], kind: "enum" });
+    }
+    // export const Name (non-function)
+    const constPattern = /export\s+const\s+(\w+)\s*(?::\s*([^=\n]+))?\s*=/g;
+    while ((match = constPattern.exec(content)) !== null) {
+        // Skip if already captured as a function
+        if (exports.some((e) => e.name === match[1]))
+            continue;
+        const type = match[2]?.trim();
+        exports.push({
+            name: match[1],
+            kind: "const",
+            signature: type || undefined,
+        });
+    }
+    return exports;
+}
+function extractPythonExports(content) {
+    const exports = [];
+    // def function_name(params) -> return_type:
+    const fnPattern = /^def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^\n:]+))?:/gm;
+    let match;
+    while ((match = fnPattern.exec(content)) !== null) {
+        if (match[1].startsWith("_"))
+            continue; // skip private
+        const params = compactParams(match[2]);
+        const ret = match[3]?.trim() || "";
+        exports.push({
+            name: match[1],
+            kind: "function",
+            signature: ret ? `(${params}) -> ${ret}` : `(${params})`,
+        });
+    }
+    // async def
+    const asyncFnPattern = /^async\s+def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^\n:]+))?:/gm;
+    while ((match = asyncFnPattern.exec(content)) !== null) {
+        if (match[1].startsWith("_"))
+            continue;
+        const params = compactParams(match[2]);
+        const ret = match[3]?.trim() || "";
+        exports.push({
+            name: match[1],
+            kind: "function",
+            signature: ret ? `(${params}) -> ${ret}` : `(${params})`,
+        });
+    }
+    // class ClassName:
+    const classPattern = /^class\s+(\w+)/gm;
+    while ((match = classPattern.exec(content)) !== null) {
+        if (match[1].startsWith("_"))
+            continue;
+        exports.push({ name: match[1], kind: "class" });
+    }
+    return exports;
+}
+function extractGoExports(content) {
+    const exports = [];
+    // func FunctionName(params) returnType
+    const fnPattern = /^func\s+(\w+)\s*\(([^)]*)\)\s*([^\n{]*)/gm;
+    let match;
+    while ((match = fnPattern.exec(content)) !== null) {
+        // Go exports start with uppercase
+        if (match[1][0] !== match[1][0].toUpperCase())
+            continue;
+        const params = compactParams(match[2]);
+        const ret = match[3]?.trim() || "";
+        exports.push({
+            name: match[1],
+            kind: "function",
+            signature: `(${params}) ${ret}`.trim(),
+        });
+    }
+    // type StructName struct
+    const structPattern = /^type\s+(\w+)\s+struct/gm;
+    while ((match = structPattern.exec(content)) !== null) {
+        if (match[1][0] !== match[1][0].toUpperCase())
+            continue;
+        exports.push({ name: match[1], kind: "class" });
+    }
+    // type InterfaceName interface
+    const ifacePattern = /^type\s+(\w+)\s+interface/gm;
+    while ((match = ifacePattern.exec(content)) !== null) {
+        if (match[1][0] !== match[1][0].toUpperCase())
+            continue;
+        exports.push({ name: match[1], kind: "interface" });
+    }
+    return exports;
+}
+function compactParams(params) {
+    if (!params.trim())
+        return "";
+    // Remove type annotations for compactness, keep param names
+    return params
+        .split(",")
+        .map((p) => {
+        const trimmed = p.trim();
+        // For destructured params, keep the whole thing compact
+        if (trimmed.startsWith("{"))
+            return "{...}";
+        // Get just the name
+        const name = trimmed.split(/[=:]/)[0].trim();
+        return name;
+    })
+        .filter(Boolean)
+        .join(", ");
+}

package/dist/detectors/middleware.d.ts

@@ -0,0 +1,2 @@
+import type { MiddlewareInfo, ProjectInfo } from "../types.js";
+export declare function detectMiddleware(files: string[], project: ProjectInfo): Promise<MiddlewareInfo[]>;

package/dist/detectors/middleware.js

@@ -0,0 +1,116 @@
+import { relative, basename } from "node:path";
+import { readFileSafe } from "../scanner.js";
+const MIDDLEWARE_PATTERNS = [
+    [
+        "auth",
+        [
+            /auth/i,
+            /jwt/i,
+            /bearer/i,
+            /passport/i,
+            /clerk/i,
+            /better-?auth/i,
+            /session/i,
+            /requireAuth/i,
+            /isAuthenticated/i,
+            /verifyToken/i,
+            /protect/i,
+        ],
+    ],
+    [
+        "rate-limit",
+        [
+            /rate.?limit/i,
+            /throttle/i,
+            /rateLimit/i,
+            /rateLimiter/i,
+            /slowDown/i,
+        ],
+    ],
+    ["cors", [/cors/i, /cross.?origin/i, /Access-Control/i]],
+    [
+        "validation",
+        [
+            /zod/i,
+            /joi/i,
+            /yup/i,
+            /validator/i,
+            /validate/i,
+            /pydantic/i,
+            /valibot/i,
+        ],
+    ],
+    [
+        "logging",
+        [
+            /logger/i,
+            /morgan/i,
+            /pino/i,
+            /winston/i,
+            /requestLogger/i,
+            /httpLogger/i,
+        ],
+    ],
+    [
+        "error-handler",
+        [
+            /errorHandler/i,
+            /error.?middleware/i,
+            /onError/i,
+            /exception.?handler/i,
+        ],
+    ],
+];
+function classifyMiddleware(name, content) {
+    const combined = name + " " + content.slice(0, 500);
+    for (const [type, patterns] of MIDDLEWARE_PATTERNS) {
+        if (patterns.some((p) => p.test(combined))) {
+            return type;
+        }
+    }
+    return "custom";
+}
+export async function detectMiddleware(files, project) {
+    const middleware = [];
+    // Look for middleware files
+    const middlewareFiles = files.filter((f) => f.includes("middleware") ||
+        f.includes("guard") ||
+        f.includes("interceptor") ||
+        basename(f).startsWith("auth") ||
+        basename(f).includes("rate") ||
+        basename(f).includes("cors"));
+    for (const file of middlewareFiles) {
+        const content = await readFileSafe(file);
+        if (!content)
+            continue;
+        const rel = relative(project.root, file);
+        const name = basename(file).replace(/\.[^.]+$/, "");
+        middleware.push({
+            name,
+            file: rel,
+            type: classifyMiddleware(name, content),
+        });
+    }
+    // Scan for inline middleware usage in route files
+    const routeFiles = files.filter((f) => (f.match(/\.(ts|js|mjs|py|go)$/) &&
+        !f.includes("node_modules") &&
+        !middlewareFiles.includes(f)));
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // app.use(cors()) or app.use(rateLimit(...))
+        const usePattern = /\.use\s*\(\s*(\w+)\s*\(/g;
+        let match;
+        while ((match = usePattern.exec(content)) !== null) {
+            const fnName = match[1];
+            const type = classifyMiddleware(fnName, "");
+            if (type !== "custom") {
+                // Deduplicate
+                if (!middleware.some((m) => m.name === fnName)) {
+                    middleware.push({ name: fnName, file: rel, type });
+                }
+            }
+        }
+    }
+    return middleware;
+}

package/dist/detectors/routes.d.ts

@@ -0,0 +1,2 @@
+import type { RouteInfo, ProjectInfo } from "../types.js";
+export declare function detectRoutes(files: string[], project: ProjectInfo): Promise<RouteInfo[]>;