codesight 1.0.0

package/dist/detectors/routes.js

@@ -0,0 +1,356 @@
+import { relative, basename } from "node:path";
+import { readFileSafe } from "../scanner.js";
+const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+const TAG_PATTERNS = [
+    ["auth", [/auth/i, /jwt/i, /token/i, /session/i, /bearer/i, /passport/i, /clerk/i, /betterAuth/i, /better-auth/i]],
+    ["db", [/prisma/i, /drizzle/i, /typeorm/i, /sequelize/i, /mongoose/i, /knex/i, /sql/i, /\.query\(/i, /\.execute\(/i, /\.findMany\(/i, /\.findFirst\(/i, /\.insert\(/i, /\.update\(/i, /\.delete\(/i]],
+    ["cache", [/redis/i, /cache/i, /memcache/i, /\.setex\(/i, /\.getex\(/i]],
+    ["queue", [/bullmq/i, /bull\b/i, /\.add\(\s*['"`]/i, /queue/i]],
+    ["email", [/resend/i, /sendgrid/i, /nodemailer/i, /\.send\(\s*\{[\s\S]*?to:/i]],
+    ["payment", [/stripe/i, /polar/i, /paddle/i, /lemon/i, /checkout/i, /webhook/i]],
+    ["upload", [/multer/i, /formidable/i, /busboy/i, /upload/i, /multipart/i]],
+    ["ai", [/openai/i, /anthropic/i, /claude/i, /\.chat\.completions/i, /\.messages\.create/i]],
+];
+function detectTags(content) {
+    const tags = [];
+    for (const [tag, patterns] of TAG_PATTERNS) {
+        if (patterns.some((p) => p.test(content))) {
+            tags.push(tag);
+        }
+    }
+    return tags;
+}
+export async function detectRoutes(files, project) {
+    const routes = [];
+    for (const fw of project.frameworks) {
+        switch (fw) {
+            case "next-app":
+                routes.push(...(await detectNextAppRoutes(files, project)));
+                break;
+            case "next-pages":
+                routes.push(...(await detectNextPagesApi(files, project)));
+                break;
+            case "hono":
+                routes.push(...(await detectHonoRoutes(files, project)));
+                break;
+            case "express":
+                routes.push(...(await detectExpressRoutes(files, project)));
+                break;
+            case "fastify":
+                routes.push(...(await detectFastifyRoutes(files, project)));
+                break;
+            case "koa":
+                routes.push(...(await detectKoaRoutes(files, project)));
+                break;
+            case "fastapi":
+                routes.push(...(await detectFastAPIRoutes(files, project)));
+                break;
+            case "flask":
+                routes.push(...(await detectFlaskRoutes(files, project)));
+                break;
+            case "django":
+                routes.push(...(await detectDjangoRoutes(files, project)));
+                break;
+            case "gin":
+            case "go-net-http":
+            case "fiber":
+                routes.push(...(await detectGoRoutes(files, project, fw)));
+                break;
+        }
+    }
+    return routes;
+}
+// --- Next.js App Router ---
+async function detectNextAppRoutes(files, project) {
+    const routeFiles = files.filter((f) => f.match(/\/app\/.*\/route\.(ts|js|tsx|jsx)$/) || f.match(/\/app\/route\.(ts|js|tsx|jsx)$/));
+    const routes = [];
+    for (const file of routeFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // Extract API path from file path
+        const pathMatch = rel.match(/(?:src\/)?app(.*)\/route\./);
+        const apiPath = pathMatch ? pathMatch[1] || "/" : "/";
+        for (const method of HTTP_METHODS) {
+            const pattern = new RegExp(`export\\s+(?:async\\s+)?function\\s+${method}\\b`);
+            if (pattern.test(content)) {
+                routes.push({
+                    method,
+                    path: apiPath,
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "next-app",
+                });
+            }
+        }
+    }
+    return routes;
+}
+// --- Next.js Pages API ---
+async function detectNextPagesApi(files, project) {
+    const apiFiles = files.filter((f) => f.match(/\/pages\/api\/.*\.(ts|js|tsx|jsx)$/));
+    const routes = [];
+    for (const file of apiFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        const pathMatch = rel.match(/(?:src\/)?pages(\/api\/.*)\.(?:ts|js|tsx|jsx)$/);
+        let apiPath = pathMatch ? pathMatch[1] : "/api";
+        apiPath = apiPath.replace(/\/index$/, "").replace(/\[([^\]]+)\]/g, ":$1");
+        // Detect methods from handler
+        const methods = [];
+        for (const method of HTTP_METHODS) {
+            if (content.includes(`req.method === '${method}'`) || content.includes(`req.method === "${method}"`)) {
+                methods.push(method);
+            }
+        }
+        if (methods.length === 0)
+            methods.push("ALL");
+        for (const method of methods) {
+            routes.push({
+                method,
+                path: apiPath,
+                file: rel,
+                tags: detectTags(content),
+                framework: "next-pages",
+            });
+        }
+    }
+    return routes;
+}
+// --- Hono ---
+async function detectHonoRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js|tsx|jsx|mjs)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("hono") && !content.includes("Hono"))
+            continue;
+        const rel = relative(project.root, file);
+        // Match: app.get("/path", ...), router.post("/path", ...), .route("/base", ...)
+        const routePattern = /\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            const path = match[2];
+            // Skip non-path strings (middleware keys like "user", "userId", etc.)
+            if (!path.startsWith("/") && !path.startsWith(":"))
+                continue;
+            routes.push({
+                method: match[1].toUpperCase(),
+                path,
+                file: rel,
+                tags: detectTags(content),
+                framework: "hono",
+            });
+        }
+    }
+    return routes;
+}
+// --- Express ---
+async function detectExpressRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("express") && !content.includes("Router"))
+            continue;
+        const rel = relative(project.root, file);
+        // Match: app.get("/path", ...), router.post("/path", ...)
+        const routePattern = /(?:app|router|server)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "express",
+            });
+        }
+    }
+    return routes;
+}
+// --- Fastify ---
+async function detectFastifyRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("fastify"))
+            continue;
+        const rel = relative(project.root, file);
+        // Match: fastify.get("/path", ...) or server.route({ method: 'GET', url: '/path' })
+        const routePattern = /(?:fastify|server|app)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "fastify",
+            });
+        }
+        // Object-style route registration
+        const objPattern = /\.route\s*\(\s*\{[\s\S]*?method:\s*['"`](\w+)['"`][\s\S]*?url:\s*['"`]([^'"`]+)['"`]/gi;
+        while ((match = objPattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "fastify",
+            });
+        }
+    }
+    return routes;
+}
+// --- Koa ---
+async function detectKoaRoutes(files, project) {
+    const tsFiles = files.filter((f) => f.match(/\.(ts|js|mjs|cjs)$/));
+    const routes = [];
+    for (const file of tsFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("koa") && !content.includes("Router"))
+            continue;
+        const rel = relative(project.root, file);
+        const routePattern = /router\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "koa",
+            });
+        }
+    }
+    return routes;
+}
+// --- FastAPI ---
+async function detectFastAPIRoutes(files, project) {
+    const pyFiles = files.filter((f) => f.endsWith(".py"));
+    const routes = [];
+    for (const file of pyFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("fastapi") && !content.includes("FastAPI") && !content.includes("APIRouter"))
+            continue;
+        const rel = relative(project.root, file);
+        // Match: @app.get("/path") or @router.post("/path") or @api_router.get("/path")
+        const routePattern = /@\w+\s*\.\s*(get|post|put|patch|delete|options)\s*\(\s*['"]([^'"]+)['"]/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: rel,
+                tags: detectTags(content),
+                framework: "fastapi",
+            });
+        }
+    }
+    return routes;
+}
+// --- Flask ---
+async function detectFlaskRoutes(files, project) {
+    const pyFiles = files.filter((f) => f.endsWith(".py"));
+    const routes = [];
+    for (const file of pyFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("flask") && !content.includes("Flask") && !content.includes("Blueprint"))
+            continue;
+        const rel = relative(project.root, file);
+        // Match: @app.route("/path", methods=["GET", "POST"])
+        const routePattern = /@(?:app|bp|blueprint)\s*\.\s*route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)/gi;
+        let match;
+        while ((match = routePattern.exec(content)) !== null) {
+            const path = match[1];
+            const methods = match[2]
+                ? match[2].match(/['"](\w+)['"]/g)?.map((m) => m.replace(/['"]/g, "").toUpperCase()) || ["GET"]
+                : ["GET"];
+            for (const method of methods) {
+                routes.push({
+                    method,
+                    path,
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: "flask",
+                });
+            }
+        }
+    }
+    return routes;
+}
+// --- Django ---
+async function detectDjangoRoutes(files, project) {
+    const pyFiles = files.filter((f) => f.endsWith(".py") && (basename(f) === "urls.py" || basename(f) === "views.py"));
+    const routes = [];
+    for (const file of pyFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        // Match: path("api/v1/users/", views.UserView.as_view())
+        const pathPattern = /path\s*\(\s*['"]([^'"]*)['"]\s*,/g;
+        let match;
+        while ((match = pathPattern.exec(content)) !== null) {
+            routes.push({
+                method: "ALL",
+                path: "/" + match[1],
+                file: rel,
+                tags: detectTags(content),
+                framework: "django",
+            });
+        }
+    }
+    return routes;
+}
+// --- Go ---
+async function detectGoRoutes(files, project, fw) {
+    const goFiles = files.filter((f) => f.endsWith(".go"));
+    const routes = [];
+    for (const file of goFiles) {
+        const content = await readFileSafe(file);
+        const rel = relative(project.root, file);
+        if (fw === "gin") {
+            // Match: r.GET("/path", handler)
+            const pattern = /\.\s*(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s*\(\s*["']([^"']+)["']/g;
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[1],
+                    path: match[2],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: fw,
+                });
+            }
+        }
+        else if (fw === "fiber") {
+            // Match: app.Get("/path", handler)
+            const pattern = /\.\s*(Get|Post|Put|Patch|Delete|Options|Head)\s*\(\s*["']([^"']+)["']/g;
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                routes.push({
+                    method: match[1].toUpperCase(),
+                    path: match[2],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: fw,
+                });
+            }
+        }
+        else {
+            // net/http: http.HandleFunc("/path", handler) or mux.HandleFunc("/path", handler)
+            const pattern = /(?:HandleFunc|Handle)\s*\(\s*["']([^"']+)["']/g;
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                routes.push({
+                    method: "ALL",
+                    path: match[1],
+                    file: rel,
+                    tags: detectTags(content),
+                    framework: fw,
+                });
+            }
+        }
+    }
+    return routes;
+}

package/dist/detectors/schema.d.ts

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

package/dist/detectors/schema.js

@@ -0,0 +1,283 @@
+import { join } from "node:path";
+import { readFileSafe } from "../scanner.js";
+const AUDIT_FIELDS = new Set([
+    "createdAt",
+    "updatedAt",
+    "deletedAt",
+    "created_at",
+    "updated_at",
+    "deleted_at",
+]);
+export async function detectSchemas(files, project) {
+    const models = [];
+    for (const orm of project.orms) {
+        switch (orm) {
+            case "drizzle":
+                models.push(...(await detectDrizzleSchemas(files, project)));
+                break;
+            case "prisma":
+                models.push(...(await detectPrismaSchemas(project)));
+                break;
+            case "typeorm":
+                models.push(...(await detectTypeORMSchemas(files, project)));
+                break;
+            case "sqlalchemy":
+                models.push(...(await detectSQLAlchemySchemas(files, project)));
+                break;
+        }
+    }
+    return models;
+}
+// --- Drizzle ORM ---
+async function detectDrizzleSchemas(files, project) {
+    const schemaFiles = files.filter((f) => f.match(/schema\.(ts|js)$/) ||
+        f.match(/\/schema\/.*\.(ts|js)$/) ||
+        f.match(/\.schema\.(ts|js)$/) ||
+        f.match(/\/db\/.*\.(ts|js)$/));
+    const models = [];
+    for (const file of schemaFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("pgTable") && !content.includes("mysqlTable") && !content.includes("sqliteTable"))
+            continue;
+        // Match: export const users = pgTable("users", { ... })
+        const tablePattern = /(?:export\s+)?const\s+(\w+)\s*=\s*(?:pgTable|mysqlTable|sqliteTable)\s*\(\s*['"`](\w+)['"`]\s*,\s*(?:\(\s*\)\s*=>\s*\(?\s*)?\{([\s\S]*?)\}\s*\)?\s*(?:,|\))/g;
+        let match;
+        while ((match = tablePattern.exec(content)) !== null) {
+            const varName = match[1];
+            const tableName = match[2];
+            const body = match[3];
+            const fields = [];
+            const relations = [];
+            // Parse fields: fieldName: dataType("col").flags()
+            const fieldPattern = /(\w+)\s*:\s*([\w.]+)\s*\(\s*(?:['"`]([^'"`]*)['"`])?\s*\)([^,\n]*)/g;
+            let fieldMatch;
+            while ((fieldMatch = fieldPattern.exec(body)) !== null) {
+                const name = fieldMatch[1];
+                if (AUDIT_FIELDS.has(name))
+                    continue;
+                const type = fieldMatch[2].replace(/.*\./, ""); // remove prefix like t.
+                const chain = fieldMatch[4] || "";
+                const flags = [];
+                if (chain.includes("primaryKey"))
+                    flags.push("pk");
+                if (chain.includes("unique"))
+                    flags.push("unique");
+                if (chain.includes("notNull"))
+                    flags.push("required");
+                if (chain.includes("default"))
+                    flags.push("default");
+                if (chain.includes("references")) {
+                    flags.push("fk");
+                    const refMatch = chain.match(/references\s*\(\s*\(\s*\)\s*=>\s*(\w+)\.(\w+)/);
+                    if (refMatch)
+                        relations.push(`${name} -> ${refMatch[1]}.${refMatch[2]}`);
+                }
+                if (name.endsWith("Id") || name.endsWith("_id")) {
+                    if (!flags.includes("fk"))
+                        flags.push("fk");
+                }
+                fields.push({ name, type, flags });
+            }
+            if (fields.length > 0) {
+                models.push({
+                    name: tableName,
+                    fields,
+                    relations,
+                    orm: "drizzle",
+                });
+            }
+        }
+        // Also detect Drizzle relations
+        const relPattern = /relations\s*\(\s*(\w+)\s*,\s*\(\s*\{([^}]+)\}\s*\)\s*=>\s*\(?\s*\{([\s\S]*?)\}\s*\)?\s*\)/g;
+        let relMatch;
+        while ((relMatch = relPattern.exec(content)) !== null) {
+            const tableName = relMatch[1];
+            const relBody = relMatch[3];
+            const model = models.find((m) => m.name === tableName);
+            if (!model)
+                continue;
+            const relEntries = /(\w+)\s*:\s*(one|many)\s*\(\s*(\w+)/g;
+            let entry;
+            while ((entry = relEntries.exec(relBody)) !== null) {
+                model.relations.push(`${entry[1]}: ${entry[2]}(${entry[3]})`);
+            }
+        }
+    }
+    return models;
+}
+// --- Prisma ---
+async function detectPrismaSchemas(project) {
+    const possiblePaths = [
+        join(project.root, "prisma/schema.prisma"),
+        join(project.root, "schema.prisma"),
+        join(project.root, "prisma/schema"),
+    ];
+    let content = "";
+    for (const p of possiblePaths) {
+        content = await readFileSafe(p);
+        if (content)
+            break;
+    }
+    if (!content)
+        return [];
+    const models = [];
+    const modelPattern = /model\s+(\w+)\s*\{([\s\S]*?)\n\}/g;
+    let match;
+    while ((match = modelPattern.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const fields = [];
+        const relations = [];
+        for (const line of body.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@"))
+                continue;
+            const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\?|\[\])?\s*(.*)/);
+            if (!fieldMatch)
+                continue;
+            const [, fieldName, fieldType, modifier, rest] = fieldMatch;
+            if (AUDIT_FIELDS.has(fieldName))
+                continue;
+            // Skip relation fields (type is another model)
+            if (rest.includes("@relation")) {
+                relations.push(`${fieldName}: ${fieldType}${modifier || ""}`);
+                continue;
+            }
+            if (modifier === "[]") {
+                relations.push(`${fieldName}: ${fieldType}[]`);
+                continue;
+            }
+            const flags = [];
+            if (rest.includes("@id"))
+                flags.push("pk");
+            if (rest.includes("@unique"))
+                flags.push("unique");
+            if (rest.includes("@default"))
+                flags.push("default");
+            if (modifier === "?")
+                flags.push("nullable");
+            if (fieldName.endsWith("Id") || fieldName.endsWith("_id"))
+                flags.push("fk");
+            fields.push({ name: fieldName, type: fieldType, flags });
+        }
+        if (fields.length > 0) {
+            models.push({ name, fields, relations, orm: "prisma" });
+        }
+    }
+    // Also detect enums
+    const enumPattern = /enum\s+(\w+)\s*\{([\s\S]*?)\n\}/g;
+    while ((match = enumPattern.exec(content)) !== null) {
+        const name = match[1];
+        const values = match[2]
+            .split("\n")
+            .map((l) => l.trim())
+            .filter((l) => l && !l.startsWith("//"));
+        models.push({
+            name: `enum:${name}`,
+            fields: values.map((v) => ({ name: v, type: "enum", flags: [] })),
+            relations: [],
+            orm: "prisma",
+        });
+    }
+    return models;
+}
+// --- TypeORM ---
+async function detectTypeORMSchemas(files, project) {
+    const entityFiles = files.filter((f) => f.match(/\.entity\.(ts|js)$/) || f.match(/entities\/.*\.(ts|js)$/));
+    const models = [];
+    for (const file of entityFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("@Entity") && !content.includes("@Column"))
+            continue;
+        // Extract entity name
+        const entityMatch = content.match(/@Entity\s*\(\s*(?:['"`](\w+)['"`])?\s*\)/);
+        const classMatch = content.match(/class\s+(\w+)/);
+        const name = entityMatch?.[1] || classMatch?.[1] || "Unknown";
+        const fields = [];
+        const relations = [];
+        // Match columns
+        const colPattern = /@(?:PrimaryGeneratedColumn|PrimaryColumn|Column|CreateDateColumn|UpdateDateColumn)\s*\(([^)]*)\)\s*\n\s*(\w+)\s*[!?]?\s*:\s*(\w+)/g;
+        let match;
+        while ((match = colPattern.exec(content)) !== null) {
+            const decorator = match[0];
+            const fieldName = match[2];
+            const fieldType = match[3];
+            if (AUDIT_FIELDS.has(fieldName))
+                continue;
+            const flags = [];
+            if (decorator.includes("PrimaryGeneratedColumn") || decorator.includes("PrimaryColumn"))
+                flags.push("pk");
+            if (decorator.includes("unique: true"))
+                flags.push("unique");
+            if (decorator.includes("nullable: true"))
+                flags.push("nullable");
+            if (decorator.includes("default:"))
+                flags.push("default");
+            fields.push({ name: fieldName, type: fieldType, flags });
+        }
+        // Match relations
+        const relPattern = /@(?:OneToMany|ManyToOne|OneToOne|ManyToMany)\s*\([^)]*\)\s*\n\s*(\w+)\s*[!?]?\s*:\s*(\w+)/g;
+        while ((match = relPattern.exec(content)) !== null) {
+            relations.push(`${match[1]}: ${match[2]}`);
+        }
+        if (fields.length > 0) {
+            models.push({ name, fields, relations, orm: "typeorm" });
+        }
+    }
+    return models;
+}
+// --- SQLAlchemy ---
+async function detectSQLAlchemySchemas(files, project) {
+    const pyFiles = files.filter((f) => f.endsWith(".py"));
+    const models = [];
+    for (const file of pyFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("Column") && !content.includes("mapped_column"))
+            continue;
+        if (!content.includes("Base") && !content.includes("DeclarativeBase") && !content.includes("Model"))
+            continue;
+        // Match class definitions
+        const classPattern = /class\s+(\w+)\s*\([^)]*(?:Base|Model|DeclarativeBase)[^)]*\)\s*:([\s\S]*?)(?=\nclass\s|\n[^\s]|\Z)/g;
+        let match;
+        while ((match = classPattern.exec(content)) !== null) {
+            const name = match[1];
+            const body = match[2];
+            const fields = [];
+            const relations = [];
+            // Match Column definitions
+            const colPattern = /(\w+)\s*(?::\s*Mapped\[([^\]]+)\]\s*=\s*mapped_column|=\s*(?:db\.)?Column)\s*\(([^)]*)\)/g;
+            let colMatch;
+            while ((colMatch = colPattern.exec(body)) !== null) {
+                const fieldName = colMatch[1];
+                if (AUDIT_FIELDS.has(fieldName))
+                    continue;
+                const mappedType = colMatch[2] || "";
+                const args = colMatch[3];
+                const flags = [];
+                if (args.includes("primary_key=True"))
+                    flags.push("pk");
+                if (args.includes("unique=True"))
+                    flags.push("unique");
+                if (args.includes("nullable=True"))
+                    flags.push("nullable");
+                if (args.includes("ForeignKey"))
+                    flags.push("fk");
+                if (args.includes("default="))
+                    flags.push("default");
+                const typeMatch = args.match(/(?:String|Integer|Boolean|Float|Text|DateTime|JSON|UUID)/);
+                const type = mappedType || typeMatch?.[0] || "unknown";
+                fields.push({ name: fieldName, type, flags });
+            }
+            // Match relationship
+            const relPattern = /(\w+)\s*=\s*relationship\s*\(\s*['"](\w+)['"]/g;
+            let relMatch;
+            while ((relMatch = relPattern.exec(body)) !== null) {
+                relations.push(`${relMatch[1]}: ${relMatch[2]}`);
+            }
+            if (fields.length > 0) {
+                models.push({ name, fields, relations, orm: "sqlalchemy" });
+            }
+        }
+    }
+    return models;
+}

package/dist/detectors/tokens.d.ts

@@ -0,0 +1,6 @@
+import type { ScanResult, TokenStats } from "../types.js";
+/**
+ * Calculates token stats: how many tokens the output uses
+ * vs. how many an AI would spend exploring the same info manually
+ */
+export declare function calculateTokenStats(result: ScanResult, outputContent: string, fileCount: number): TokenStats;