codesight 1.4.0 → 1.5.1

package/dist/ast/extract-go.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Go structured parser for routes and models.
+ * Uses brace-tracking + regex for near-AST accuracy on Go's regular syntax.
+ *
+ * Go's syntax is regular enough that structured parsing (tracking braces,
+ * extracting struct bodies, parsing field tags) achieves AST-level accuracy
+ * without needing the Go compiler.
+ *
+ * Extracts:
+ * - Gin/Fiber/Echo/Chi/net-http routes with group prefixes
+ * - GORM model structs with field types, tags (primaryKey, unique, etc.)
+ */
+import type { RouteInfo, SchemaModel, Framework } from "../types.js";
+/**
+ * Extract routes from a Go file with group/prefix tracking.
+ * Works for Gin, Fiber, Echo, Chi, and net/http.
+ */
+export declare function extractGoRoutesStructured(filePath: string, content: string, framework: Framework, tags: string[]): RouteInfo[];
+/**
+ * Extract GORM model structs from a Go file.
+ * Parses struct bodies, field types, and gorm tags.
+ */
+export declare function extractGORMModelsStructured(_filePath: string, content: string): SchemaModel[];

package/dist/ast/extract-go.js

@@ -0,0 +1,331 @@
+/**
+ * Go structured parser for routes and models.
+ * Uses brace-tracking + regex for near-AST accuracy on Go's regular syntax.
+ *
+ * Go's syntax is regular enough that structured parsing (tracking braces,
+ * extracting struct bodies, parsing field tags) achieves AST-level accuracy
+ * without needing the Go compiler.
+ *
+ * Extracts:
+ * - Gin/Fiber/Echo/Chi/net-http routes with group prefixes
+ * - GORM model structs with field types, tags (primaryKey, unique, etc.)
+ */
+/**
+ * Extract routes from a Go file with group/prefix tracking.
+ * Works for Gin, Fiber, Echo, Chi, and net/http.
+ */
+export function extractGoRoutesStructured(filePath, content, framework, tags) {
+    const routes = [];
+    // Step 1: Find route groups with prefixes
+    // Gin: r.Group("/api") / g := r.Group("/v1")
+    // Echo: g := e.Group("/api")
+    // Fiber: api := app.Group("/api")
+    // Chi: r.Route("/api", func(r chi.Router) { ... })
+    const groups = extractRouteGroups(content, framework);
+    // Collect group variable names to exclude from top-level scan
+    const groupVarNames = new Set();
+    // Step 2: Extract routes from each group with prefix resolution
+    for (const group of groups) {
+        // Track which variable this group belongs to
+        if (group.varName)
+            groupVarNames.add(group.varName);
+        const groupRoutes = extractRoutesFromBlock(group.body, framework, filePath, tags);
+        for (const route of groupRoutes) {
+            route.path = normalizePath(group.prefix + "/" + route.path);
+            routes.push(route);
+        }
+    }
+    // Step 3: Extract top-level routes (only from lines NOT belonging to group vars)
+    // Filter out lines that reference group variables to avoid duplicates
+    if (groupVarNames.size > 0) {
+        const lines = content.split("\n");
+        const topLines = lines.filter((line) => {
+            for (const v of groupVarNames) {
+                if (line.includes(v + "."))
+                    return false;
+            }
+            return true;
+        });
+        const topContent = topLines.join("\n");
+        const topLevelRoutes = extractRoutesFromBlock(topContent, framework, filePath, tags);
+        routes.push(...topLevelRoutes);
+    }
+    else {
+        const topLevelRoutes = extractRoutesFromBlock(content, framework, filePath, tags);
+        routes.push(...topLevelRoutes);
+    }
+    // Deduplicate
+    const seen = new Set();
+    return routes.filter((r) => {
+        const key = `${r.method}:${r.path}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function extractRouteGroups(content, framework) {
+    const groups = [];
+    if (framework === "chi") {
+        // Chi: r.Route("/prefix", func(r chi.Router) { ... })
+        const chiRoutePattern = /\.Route\s*\(\s*"([^"]+)"\s*,\s*func\s*\([^)]*\)\s*\{/g;
+        let match;
+        while ((match = chiRoutePattern.exec(content)) !== null) {
+            const prefix = match[1];
+            const bodyStart = match.index + match[0].length;
+            const body = extractBraceBlock(content, bodyStart);
+            if (body)
+                groups.push({ prefix, body });
+        }
+    }
+    else {
+        // Gin/Echo/Fiber: varName := receiver.Group("/prefix")
+        // Build a prefix map to resolve chained groups: api := r.Group("/api"), users := api.Group("/users")
+        const prefixMap = new Map(); // varName -> resolved full prefix
+        const groupPattern = /(\w+)\s*:?=\s*(\w+)\.Group\s*\(\s*"([^"]*)"/g;
+        let match;
+        // First pass: build prefix chain
+        while ((match = groupPattern.exec(content)) !== null) {
+            const varName = match[1];
+            const receiver = match[2];
+            const prefix = match[3];
+            // Resolve receiver prefix (if receiver is itself a group)
+            const receiverPrefix = prefixMap.get(receiver) || "";
+            const fullPrefix = normalizePath(receiverPrefix + "/" + prefix);
+            prefixMap.set(varName, fullPrefix);
+        }
+        // Second pass: extract routes for each group variable
+        for (const [varName, fullPrefix] of prefixMap) {
+            const varRoutes = [];
+            // Match routes — allow empty path strings with ([^"]*)
+            const varPattern = new RegExp(`${escapeRegex(varName)}\\.\\s*(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD|Get|Post|Put|Patch|Delete|Options|Head)\\s*\\(\\s*"([^"]*)"`, "g");
+            let routeMatch;
+            while ((routeMatch = varPattern.exec(content)) !== null) {
+                varRoutes.push(`${routeMatch[1]}:${routeMatch[2]}`);
+            }
+            // Also handle HandleFunc for mixed patterns
+            const handlePattern = new RegExp(`${escapeRegex(varName)}\\.\\s*HandleFunc\\s*\\(\\s*"([^"]*)"`, "g");
+            while ((routeMatch = handlePattern.exec(content)) !== null) {
+                varRoutes.push(`ALL:${routeMatch[1]}`);
+            }
+            if (varRoutes.length > 0) {
+                groups.push({
+                    prefix: fullPrefix,
+                    varName,
+                    body: varRoutes
+                        .map((r) => {
+                        const colonIdx = r.indexOf(":");
+                        const m = r.slice(0, colonIdx);
+                        const p = r.slice(colonIdx + 1);
+                        return `FAKE.${m}("${p}")`;
+                    })
+                        .join("\n"),
+                });
+            }
+        }
+    }
+    return groups;
+}
+function extractRoutesFromBlock(block, framework, filePath, tags) {
+    const routes = [];
+    if (framework === "gin" || framework === "echo") {
+        // .GET("/path", handler) — uppercase methods (allow empty path)
+        const pattern = /\.(?:FAKE\.)?(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s*\(\s*"([^"]*)"/g;
+        let match;
+        while ((match = pattern.exec(block)) !== null) {
+            routes.push({
+                method: match[1],
+                path: match[2],
+                file: filePath,
+                tags,
+                framework,
+                params: extractPathParams(match[2]),
+                confidence: "ast",
+            });
+        }
+    }
+    else if (framework === "fiber" || framework === "chi") {
+        // .Get("/path", handler) — PascalCase methods (allow empty path)
+        const pattern = /\.(?:FAKE\.)?(Get|Post|Put|Patch|Delete|Options|Head)\s*\(\s*"([^"]*)"/g;
+        let match;
+        while ((match = pattern.exec(block)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: filePath,
+                tags,
+                framework,
+                params: extractPathParams(match[2]),
+                confidence: "ast",
+            });
+        }
+    }
+    // net/http: HandleFunc or Handle
+    if (framework === "go-net-http" || framework === "chi") {
+        const pattern = /\.(?:HandleFunc|Handle)\s*\(\s*"([^"]+)"/g;
+        let match;
+        while ((match = pattern.exec(block)) !== null) {
+            // Go 1.22+: "GET /path" patterns
+            const pathStr = match[1];
+            let method = "ALL";
+            let path = pathStr;
+            const methodMatch = pathStr.match(/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s+(\/.*)/);
+            if (methodMatch) {
+                method = methodMatch[1];
+                path = methodMatch[2];
+            }
+            routes.push({
+                method,
+                path,
+                file: filePath,
+                tags,
+                framework,
+                params: extractPathParams(path),
+                confidence: "ast",
+            });
+        }
+    }
+    // Chi: r.Get, r.Post etc. (also catch Method pattern)
+    if (framework === "chi") {
+        const methodPattern = /\.Method\s*\(\s*"(\w+)"\s*,\s*"([^"]+)"/g;
+        let match;
+        while ((match = methodPattern.exec(block)) !== null) {
+            routes.push({
+                method: match[1].toUpperCase(),
+                path: match[2],
+                file: filePath,
+                tags,
+                framework,
+                params: extractPathParams(match[2]),
+                confidence: "ast",
+            });
+        }
+    }
+    return routes;
+}
+// ─── GORM Model Extraction ───
+/**
+ * Extract GORM model structs from a Go file.
+ * Parses struct bodies, field types, and gorm tags.
+ */
+export function extractGORMModelsStructured(_filePath, content) {
+    const models = [];
+    // Find structs that embed gorm.Model or have gorm tags
+    const structPattern = /type\s+(\w+)\s+struct\s*\{/g;
+    let match;
+    while ((match = structPattern.exec(content)) !== null) {
+        const name = match[1];
+        const bodyStart = match.index + match[0].length;
+        const body = extractBraceBlock(content, bodyStart);
+        if (!body)
+            continue;
+        // Check if this is a GORM model
+        const isGormModel = body.includes("gorm.Model") ||
+            body.includes("gorm.DeletedAt") ||
+            body.includes("`gorm:") ||
+            body.includes("`json:");
+        if (!isGormModel)
+            continue;
+        const fields = [];
+        const relations = [];
+        const lines = body.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("//") || trimmed === "}" || trimmed === "{")
+                continue;
+            // Embedded model: gorm.Model
+            if (trimmed === "gorm.Model") {
+                fields.push({ name: "ID", type: "uint", flags: ["pk"] });
+                fields.push({ name: "CreatedAt", type: "time.Time", flags: [] });
+                fields.push({ name: "UpdatedAt", type: "time.Time", flags: [] });
+                fields.push({ name: "DeletedAt", type: "gorm.DeletedAt", flags: ["nullable"] });
+                continue;
+            }
+            // Parse field: Name Type `gorm:"..." json:"..."`
+            const fieldMatch = trimmed.match(/^(\w+)\s+([\w.*\[\]]+)\s*(?:`(.+)`)?/);
+            if (!fieldMatch)
+                continue;
+            const fieldName = fieldMatch[1];
+            const fieldType = fieldMatch[2];
+            const tagStr = fieldMatch[3] || "";
+            // Skip embedded structs that aren't fields
+            if (fieldType.startsWith("*") || fieldType.includes(".")) {
+                // Check if it's a relation
+                if (trimmed.includes("gorm:\"foreignKey") || trimmed.includes("gorm:\"many2many")) {
+                    relations.push(`${fieldName}: ${fieldType.replace("*", "").replace("[]", "")}`);
+                    continue;
+                }
+                // Check for belongs_to / has_many by type
+                if (fieldType.startsWith("[]") || fieldType.startsWith("*")) {
+                    const relType = fieldType.replace("*", "").replace("[]", "");
+                    if (relType[0] === relType[0]?.toUpperCase() && !relType.includes(".")) {
+                        relations.push(`${fieldName}: ${relType}`);
+                        continue;
+                    }
+                }
+            }
+            const flags = [];
+            // Parse gorm tag
+            const gormTag = tagStr.match(/gorm:"([^"]+)"/)?.[1] || "";
+            if (gormTag) {
+                if (gormTag.includes("primaryKey") || gormTag.includes("primarykey"))
+                    flags.push("pk");
+                if (gormTag.includes("unique"))
+                    flags.push("unique");
+                if (gormTag.includes("not null"))
+                    flags.push("required");
+                if (gormTag.includes("default:"))
+                    flags.push("default");
+                if (gormTag.includes("index"))
+                    flags.push("index");
+                if (gormTag.includes("foreignKey") || gormTag.includes("foreignkey"))
+                    flags.push("fk");
+            }
+            fields.push({ name: fieldName, type: fieldType, flags });
+        }
+        if (fields.length > 0) {
+            models.push({
+                name,
+                fields,
+                relations,
+                orm: "gorm",
+                confidence: "ast",
+            });
+        }
+    }
+    return models;
+}
+// ─── Helpers ───
+/**
+ * Extract the content between matched braces starting at position.
+ * Returns the content inside the braces (not including the opening brace).
+ */
+function extractBraceBlock(content, startAfterOpenBrace) {
+    let depth = 1;
+    let i = startAfterOpenBrace;
+    while (i < content.length && depth > 0) {
+        if (content[i] === "{")
+            depth++;
+        else if (content[i] === "}")
+            depth--;
+        i++;
+    }
+    if (depth !== 0)
+        return null;
+    return content.slice(startAfterOpenBrace, i - 1);
+}
+function extractPathParams(path) {
+    const params = [];
+    // Gin/Echo: :param, Chi: {param}, Go 1.22: {param}
+    const regex = /[:{}](\w+)/g;
+    let m;
+    while ((m = regex.exec(path)) !== null)
+        params.push(m[1]);
+    return params;
+}
+function normalizePath(path) {
+    return path.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/ast/extract-python.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Python AST extraction via subprocess.
+ * Spawns python3 with an inline script using stdlib `ast` module.
+ * Zero dependencies — if the project uses Python, the interpreter is there.
+ *
+ * Extracts:
+ * - FastAPI/Flask route decorators with precise path + method
+ * - Django urlpatterns with path() calls
+ * - SQLAlchemy model classes with Column types, flags, and relationships
+ */
+import type { RouteInfo, SchemaModel, Framework } from "../types.js";
+/**
+ * Extract routes from a Python file using AST.
+ * Returns routes with confidence: "ast", or null if Python is unavailable.
+ */
+export declare function extractPythonRoutesAST(filePath: string, content: string, framework: Framework, tags: string[]): Promise<RouteInfo[] | null>;
+/**
+ * Extract SQLAlchemy models from a Python file using AST.
+ * Returns models with confidence: "ast", or null if Python is unavailable.
+ */
+export declare function extractSQLAlchemyAST(filePath: string, content: string): Promise<SchemaModel[] | null>;
+/**
+ * Check if Python 3 is available on this system.
+ */
+export declare function isPythonAvailable(): Promise<boolean>;

package/dist/ast/extract-python.js

@@ -0,0 +1,388 @@
+/**
+ * Python AST extraction via subprocess.
+ * Spawns python3 with an inline script using stdlib `ast` module.
+ * Zero dependencies — if the project uses Python, the interpreter is there.
+ *
+ * Extracts:
+ * - FastAPI/Flask route decorators with precise path + method
+ * - Django urlpatterns with path() calls
+ * - SQLAlchemy model classes with Column types, flags, and relationships
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileP = promisify(execFile);
+// The Python script that does AST parsing via stdlib
+// Outputs JSON to stdout
+const PYTHON_ROUTE_SCRIPT = `
+import ast, json, sys
+
+def extract_routes(source, filename):
+    try:
+        tree = ast.parse(source, filename)
+    except SyntaxError:
+        return []
+
+    routes = []
+
+    for node in ast.walk(tree):
+        # FastAPI/Flask style: @router.get("/path") or @app.route("/path", methods=["GET","POST"])
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            for dec in node.decorator_list:
+                route = parse_route_decorator(dec)
+                if route:
+                    for r in route:
+                        routes.append(r)
+
+        # Django: path("url", view) in urlpatterns list
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == 'urlpatterns':
+                    if isinstance(node.value, (ast.List, ast.BinOp)):
+                        routes.extend(parse_urlpatterns(node.value))
+
+    return routes
+
+def parse_route_decorator(dec):
+    results = []
+
+    # @router.get("/path") / @app.post("/path") — Attribute call
+    if isinstance(dec, ast.Call) and isinstance(dec.func, ast.Attribute):
+        method_name = dec.func.attr.upper()
+        methods_map = {'GET':'GET','POST':'POST','PUT':'PUT','PATCH':'PATCH',
+                       'DELETE':'DELETE','OPTIONS':'OPTIONS','HEAD':'HEAD'}
+
+        if method_name in methods_map and dec.args:
+            path = get_str(dec.args[0])
+            if path is not None:
+                results.append({'method': methods_map[method_name], 'path': path})
+
+        # @app.route("/path", methods=["GET","POST"])
+        if dec.func.attr == 'route' and dec.args:
+            path = get_str(dec.args[0])
+            if path is not None:
+                methods = ['GET']
+                for kw in dec.keywords:
+                    if kw.arg == 'methods' and isinstance(kw.value, ast.List):
+                        methods = [get_str(e) for e in kw.value.elts if get_str(e)]
+                for m in methods:
+                    results.append({'method': m.upper(), 'path': path})
+
+    # @app.api_route("/path", methods=["GET","POST"]) — FastAPI api_route
+    if isinstance(dec, ast.Call) and isinstance(dec.func, ast.Attribute):
+        if dec.func.attr == 'api_route' and dec.args:
+            path = get_str(dec.args[0])
+            if path is not None:
+                methods = ['GET']
+                for kw in dec.keywords:
+                    if kw.arg == 'methods' and isinstance(kw.value, ast.List):
+                        methods = [get_str(e) for e in kw.value.elts if get_str(e)]
+                for m in methods:
+                    results.append({'method': m.upper(), 'path': path})
+
+    return results if results else None
+
+def parse_urlpatterns(node):
+    routes = []
+    elements = []
+    if isinstance(node, ast.List):
+        elements = node.elts
+    elif isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+        # urlpatterns = [...] + [...]
+        if isinstance(node.left, ast.List):
+            elements.extend(node.left.elts)
+        if isinstance(node.right, ast.List):
+            elements.extend(node.right.elts)
+
+    for elt in elements:
+        if isinstance(elt, ast.Call):
+            func_name = ''
+            if isinstance(elt.func, ast.Name):
+                func_name = elt.func.id
+            elif isinstance(elt.func, ast.Attribute):
+                func_name = elt.func.attr
+
+            if func_name in ('path', 're_path', 'url') and elt.args:
+                path_str = get_str(elt.args[0])
+                if path_str is not None:
+                    routes.append({'method': 'ALL', 'path': '/' + path_str.lstrip('/')})
+
+    return routes
+
+def get_str(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    if isinstance(node, ast.Str):  # Python 3.7
+        return node.s
+    return None
+
+source = sys.stdin.read()
+filename = sys.argv[1] if len(sys.argv) > 1 else '<stdin>'
+result = extract_routes(source, filename)
+print(json.dumps(result))
+`;
+const PYTHON_SCHEMA_SCRIPT = `
+import ast, json, sys
+
+def extract_models(source, filename):
+    try:
+        tree = ast.parse(source, filename)
+    except SyntaxError:
+        return []
+
+    models = []
+
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ClassDef):
+            continue
+
+        # Check if inherits from Base, Model, DeclarativeBase, db.Model
+        is_model = False
+        for base in node.bases:
+            name = ''
+            if isinstance(base, ast.Name):
+                name = base.id
+            elif isinstance(base, ast.Attribute):
+                name = base.attr
+            if name in ('Base', 'Model', 'DeclarativeBase', 'AbstractBase'):
+                is_model = True
+                break
+        if not is_model:
+            continue
+
+        fields = []
+        relations = []
+
+        for item in node.body:
+            # Column assignments: field = Column(Type, ...) or field: Mapped[Type] = mapped_column(...)
+            if isinstance(item, ast.Assign):
+                for target in item.targets:
+                    if isinstance(target, ast.Name):
+                        field_info = parse_column_or_rel(target.id, item.value)
+                        if field_info:
+                            if field_info['kind'] == 'field':
+                                fields.append(field_info)
+                            else:
+                                relations.append(field_info)
+
+            if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
+                field_name = item.target.id
+                if field_name.startswith('__'):
+                    continue
+                if item.value:
+                    field_info = parse_column_or_rel(field_name, item.value)
+                    if field_info:
+                        if field_info['kind'] == 'field':
+                            # Try to get type from annotation
+                            ann_type = extract_mapped_type(item.annotation)
+                            if ann_type and field_info['type'] == 'unknown':
+                                field_info['type'] = ann_type
+                            fields.append(field_info)
+                        else:
+                            relations.append(field_info)
+
+        if fields:
+            models.append({
+                'name': node.name,
+                'fields': fields,
+                'relations': relations,
+            })
+
+    return models
+
+def parse_column_or_rel(name, value):
+    if name.startswith('__'):
+        return None
+
+    # relationship("Model")
+    if isinstance(value, ast.Call):
+        func_name = get_func_name(value)
+
+        if func_name in ('relationship', 'db.relationship'):
+            target = ''
+            if value.args:
+                target = get_str(value.args[0]) or ''
+            return {'kind': 'relation', 'name': name, 'target': target}
+
+        if func_name in ('Column', 'db.Column', 'mapped_column'):
+            col_type = 'unknown'
+            flags = []
+
+            for arg in value.args:
+                t = get_type_name(arg)
+                if t:
+                    col_type = t
+                if isinstance(arg, ast.Call) and get_func_name(arg) == 'ForeignKey':
+                    flags.append('fk')
+
+            for kw in value.keywords:
+                if kw.arg == 'primary_key' and is_true(kw.value):
+                    flags.append('pk')
+                elif kw.arg == 'unique' and is_true(kw.value):
+                    flags.append('unique')
+                elif kw.arg == 'nullable' and is_true(kw.value):
+                    flags.append('nullable')
+                elif kw.arg == 'default':
+                    flags.append('default')
+                elif kw.arg == 'index' and is_true(kw.value):
+                    flags.append('index')
+
+            return {'kind': 'field', 'name': name, 'type': col_type, 'flags': flags}
+
+    return None
+
+def extract_mapped_type(annotation):
+    # Mapped[int] or Mapped[Optional[str]]
+    if isinstance(annotation, ast.Subscript):
+        if isinstance(annotation.value, ast.Name) and annotation.value.id == 'Mapped':
+            slice_node = annotation.slice
+            if isinstance(slice_node, ast.Name):
+                return slice_node.id
+            if isinstance(slice_node, ast.Subscript) and isinstance(slice_node.value, ast.Name):
+                if slice_node.value.id == 'Optional':
+                    inner = slice_node.slice
+                    if isinstance(inner, ast.Name):
+                        return inner.id
+    return None
+
+def get_func_name(node):
+    if isinstance(node.func, ast.Name):
+        return node.func.id
+    if isinstance(node.func, ast.Attribute):
+        if isinstance(node.func.value, ast.Name):
+            return node.func.value.id + '.' + node.func.attr
+        return node.func.attr
+    return ''
+
+def get_type_name(node):
+    if isinstance(node, ast.Name):
+        known = {'String','Integer','Boolean','Float','Text','DateTime','JSON',
+                 'UUID','BigInteger','SmallInteger','Numeric','Date','Time',
+                 'LargeBinary','Enum','ARRAY','JSONB'}
+        if node.id in known:
+            return node.id
+    if isinstance(node, ast.Call):
+        return get_type_name(node.func)
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    return None
+
+def get_str(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    return None
+
+def is_true(node):
+    if isinstance(node, ast.Constant):
+        return node.value is True
+    if isinstance(node, ast.NameConstant):  # Python 3.7
+        return node.value is True
+    return False
+
+source = sys.stdin.read()
+filename = sys.argv[1] if len(sys.argv) > 1 else '<stdin>'
+result = extract_models(source, filename)
+print(json.dumps(result))
+`;
+let pythonAvailable = null;
+let pythonCmd = "python3";
+async function findPython() {
+    if (pythonAvailable !== null)
+        return pythonAvailable;
+    for (const cmd of ["python3", "python"]) {
+        try {
+            const { stdout } = await execFileP(cmd, ["--version"], { timeout: 3000 });
+            if (stdout.includes("Python 3")) {
+                pythonCmd = cmd;
+                pythonAvailable = true;
+                return true;
+            }
+        }
+        catch { }
+    }
+    pythonAvailable = false;
+    return false;
+}
+import { spawn } from "node:child_process";
+async function runPythonWithStdin(script, source, filename) {
+    if (!(await findPython()))
+        return null;
+    return new Promise((resolve) => {
+        const proc = spawn(pythonCmd, ["-c", script, filename], {
+            timeout: 10000,
+            env: { ...process.env, PYTHONDONTWRITEBYTECODE: "1" },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => { stdout += data.toString(); });
+        proc.stderr.on("data", (data) => { stderr += data.toString(); });
+        proc.on("close", (code) => {
+            if (code !== 0 || !stdout.trim()) {
+                resolve(null);
+                return;
+            }
+            try {
+                resolve(JSON.parse(stdout.trim()));
+            }
+            catch {
+                resolve(null);
+            }
+        });
+        proc.on("error", () => resolve(null));
+        proc.stdin.write(source);
+        proc.stdin.end();
+    });
+}
+/**
+ * Extract routes from a Python file using AST.
+ * Returns routes with confidence: "ast", or null if Python is unavailable.
+ */
+export async function extractPythonRoutesAST(filePath, content, framework, tags) {
+    const result = await runPythonWithStdin(PYTHON_ROUTE_SCRIPT, content, filePath);
+    if (!result || !Array.isArray(result) || result.length === 0)
+        return null;
+    return result.map((r) => ({
+        method: r.method,
+        path: r.path,
+        file: filePath,
+        tags,
+        framework,
+        params: extractPathParams(r.path),
+        confidence: "ast",
+    }));
+}
+/**
+ * Extract SQLAlchemy models from a Python file using AST.
+ * Returns models with confidence: "ast", or null if Python is unavailable.
+ */
+export async function extractSQLAlchemyAST(filePath, content) {
+    const result = await runPythonWithStdin(PYTHON_SCHEMA_SCRIPT, content, filePath);
+    if (!result || !Array.isArray(result) || result.length === 0)
+        return null;
+    return result.map((m) => ({
+        name: m.name,
+        fields: (m.fields || []).map((f) => ({
+            name: f.name,
+            type: f.type || "unknown",
+            flags: f.flags || [],
+        })),
+        relations: (m.relations || []).map((r) => `${r.name}: ${r.target}`),
+        orm: "sqlalchemy",
+        confidence: "ast",
+    }));
+}
+/**
+ * Check if Python 3 is available on this system.
+ */
+export async function isPythonAvailable() {
+    return findPython();
+}
+function extractPathParams(path) {
+    const params = [];
+    // FastAPI: {param} / Flask: <param> / Django: <type:param>
+    const regex = /[{<](?:\w+:)?(\w+)[}>]/g;
+    let m;
+    while ((m = regex.exec(path)) !== null)
+        params.push(m[1]);
+    return params;
+}

package/dist/detectors/routes.js

@@ -2,6 +2,8 @@ import { relative, basename } from "node:path";
 import { readFileSafe } from "../scanner.js";
 import { loadTypeScript } from "../ast/loader.js";
 import { extractRoutesAST } from "../ast/extract-routes.js";
+import { extractPythonRoutesAST } from "../ast/extract-python.js";
+import { extractGoRoutesStructured } from "../ast/extract-go.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]],
@@ -581,6 +583,14 @@ async function detectFastAPIRoutes(files, project) {
         if (!content.includes("fastapi") && !content.includes("FastAPI") && !content.includes("APIRouter"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        // Try Python AST first
+        const astRoutes = await extractPythonRoutesAST(rel, content, "fastapi", tags);
+        if (astRoutes && astRoutes.length > 0) {
+            routes.push(...astRoutes);
+            continue;
+        }
+        // Fallback to regex
         const routePattern = /@\w+\s*\.\s*(get|post|put|patch|delete|options)\s*\(\s*['"]([^'"]+)['"]/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -588,7 +598,7 @@ async function detectFastAPIRoutes(files, project) {
                 method: match[1].toUpperCase(),
                 path: match[2],
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "fastapi",
             });
         }
@@ -604,6 +614,14 @@ async function detectFlaskRoutes(files, project) {
         if (!content.includes("flask") && !content.includes("Flask") && !content.includes("Blueprint"))
             continue;
         const rel = relative(project.root, file);
+        const tags = detectTags(content);
+        // Try Python AST first
+        const astRoutes = await extractPythonRoutesAST(rel, content, "flask", tags);
+        if (astRoutes && astRoutes.length > 0) {
+            routes.push(...astRoutes);
+            continue;
+        }
+        // Fallback to regex
         const routePattern = /@(?:app|bp|blueprint|\w+)\s*\.\s*route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)/gi;
         let match;
         while ((match = routePattern.exec(content)) !== null) {
@@ -616,7 +634,7 @@ async function detectFlaskRoutes(files, project) {
                     method,
                     path,
                     file: rel,
-                    tags: detectTags(content),
+                    tags,
                     framework: "flask",
                 });
             }
@@ -631,7 +649,14 @@ async function detectDjangoRoutes(files, project) {
     for (const file of pyFiles) {
         const content = await readFileSafe(file);
         const rel = relative(project.root, file);
-        // path("api/v1/users/", views.UserView.as_view())
+        const tags = detectTags(content);
+        // Try Python AST first
+        const astRoutes = await extractPythonRoutesAST(rel, content, "django", tags);
+        if (astRoutes && astRoutes.length > 0) {
+            routes.push(...astRoutes);
+            continue;
+        }
+        // Fallback to regex
         const pathPattern = /path\s*\(\s*['"]([^'"]*)['"]\s*,/g;
         let match;
         while ((match = pathPattern.exec(content)) !== null) {
@@ -639,7 +664,7 @@ async function detectDjangoRoutes(files, project) {
                 method: "ALL",
                 path: "/" + match[1],
                 file: rel,
-                tags: detectTags(content),
+                tags,
                 framework: "django",
             });
         }
@@ -653,72 +678,43 @@ async function detectGoRoutes(files, project, fw) {
     for (const file of goFiles) {
         const content = await readFileSafe(file);
         const rel = relative(project.root, file);
-        if (fw === "gin") {
-            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") {
-            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,
-                });
-            }
+        const tags = detectTags(content);
+        // Use structured parser (brace-tracking + group prefix resolution)
+        const structuredRoutes = extractGoRoutesStructured(rel, content, fw, tags);
+        if (structuredRoutes.length > 0) {
+            routes.push(...structuredRoutes);
+            continue;
         }
-        else if (fw === "echo") {
-            // e.GET("/path", handler) or g.POST("/path", handler)
+        // Fallback to simple regex for files where structured parser found nothing
+        if (fw === "gin" || fw === "echo") {
             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,
-                });
+                routes.push({ method: match[1], path: match[2], file: rel, tags, framework: fw });
             }
         }
-        else if (fw === "chi") {
-            // r.Get("/path", handler), r.Post("/path", handler)
+        else if (fw === "fiber" || fw === "chi") {
             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,
-                });
+                routes.push({ method: match[1].toUpperCase(), path: match[2], file: rel, tags, framework: fw });
             }
         }
         else {
-            // net/http: http.HandleFunc("/path", handler) or mux.HandleFunc("/path", handler)
+            // net/http
             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,
-                });
+                // Go 1.22+: "GET /path" patterns
+                const pathStr = match[1];
+                let method = "ALL";
+                let path = pathStr;
+                const methodMatch = pathStr.match(/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s+(\/.*)/);
+                if (methodMatch) {
+                    method = methodMatch[1];
+                    path = methodMatch[2];
+                }
+                routes.push({ method, path, file: rel, tags, framework: fw });
             }
         }
     }

package/dist/detectors/schema.js

@@ -1,7 +1,9 @@
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { readFileSafe } from "../scanner.js";
 import { loadTypeScript } from "../ast/loader.js";
 import { extractDrizzleSchemaAST, extractTypeORMSchemaAST } from "../ast/extract-schema.js";
+import { extractSQLAlchemyAST } from "../ast/extract-python.js";
+import { extractGORMModelsStructured } from "../ast/extract-go.js";
 const AUDIT_FIELDS = new Set([
     "createdAt",
     "updatedAt",
@@ -26,6 +28,9 @@ export async function detectSchemas(files, project) {
             case "sqlalchemy":
                 models.push(...(await detectSQLAlchemySchemas(files, project)));
                 break;
+            case "gorm":
+                models.push(...(await detectGORMSchemas(files, project)));
+                break;
         }
     }
     return models;
@@ -256,7 +261,14 @@ async function detectSQLAlchemySchemas(files, project) {
             continue;
         if (!content.includes("Base") && !content.includes("DeclarativeBase") && !content.includes("Model"))
             continue;
-        // Match class definitions
+        const rel = relative(project.root, file);
+        // Try Python AST first
+        const astModels = await extractSQLAlchemyAST(rel, content);
+        if (astModels && astModels.length > 0) {
+            models.push(...astModels);
+            continue;
+        }
+        // Fallback to regex
         const classPattern = /class\s+(\w+)\s*\([^)]*(?:Base|Model|DeclarativeBase)[^)]*\)\s*:([\s\S]*?)(?=\nclass\s|\n[^\s]|$)/g;
         let match;
         while ((match = classPattern.exec(content)) !== null) {
@@ -301,3 +313,17 @@ async function detectSQLAlchemySchemas(files, project) {
     }
     return models;
 }
+// --- GORM ---
+async function detectGORMSchemas(files, _project) {
+    const goFiles = files.filter((f) => f.endsWith(".go"));
+    const models = [];
+    for (const file of goFiles) {
+        const content = await readFileSafe(file);
+        if (!content.includes("gorm") && !content.includes("Model") && !content.includes("`json:"))
+            continue;
+        const rel = relative(_project.root, file);
+        const structModels = extractGORMModelsStructured(rel, content);
+        models.push(...structModels);
+    }
+    return models;
+}

package/dist/formatter.js

@@ -239,7 +239,9 @@ function formatCombined(result, sections) {
     // Token stats
     const ts = result.tokenStats;
     lines.push(`> ${result.routes.length} routes | ${result.schemas.length} models | ${result.components.length} components | ${result.libs.length} lib files | ${result.config.envVars.length} env vars | ${result.middleware.length} middleware | ${result.graph.edges.length} import links`);
-    lines.push(`> **Token savings:** this file is ~${ts.outputTokens.toLocaleString()} tokens. Without it, AI exploration would cost ~${ts.estimatedExplorationTokens.toLocaleString()} tokens. **Saves ~${ts.saved.toLocaleString()} tokens per conversation.**`);
+    // Round to nearest 100 to keep output deterministic across runs (avoids git conflicts in worktrees)
+    const roundTo100 = (n) => Math.round(n / 100) * 100;
+    lines.push(`> **Token savings:** this file is ~${roundTo100(ts.outputTokens).toLocaleString()} tokens. Without it, AI exploration would cost ~${roundTo100(ts.estimatedExplorationTokens).toLocaleString()} tokens. **Saves ~${roundTo100(ts.saved).toLocaleString()} tokens per conversation.**`);
     lines.push("");
     lines.push("---");
     lines.push("");

package/dist/index.js

@@ -15,7 +15,7 @@ import { writeOutput } from "./formatter.js";
 import { generateAIConfigs } from "./generators/ai-config.js";
 import { generateHtmlReport } from "./generators/html-report.js";
 import { loadConfig, mergeCliConfig } from "./config.js";
-const VERSION = "1.4.0";
+const VERSION = "1.5.1";
 const BRAND = "codesight";
 function printHelp() {
     console.log(`
@@ -396,9 +396,9 @@ async function main() {
         const reportPath = await generateHtmlReport(result, outputDir);
         console.log(` ${outputDirName}/report.html`);
         if (doOpen) {
-            const { exec } = await import("node:child_process");
+            const { execFile } = await import("node:child_process");
             const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-            exec(`${cmd} "${reportPath}"`);
+            execFile(cmd, [reportPath]);
             console.log("  Opening in browser...");
         }
     }

package/dist/scanner.js

@@ -90,7 +90,7 @@ export async function detectProject(root) {
         pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
     }
     catch { }
-    const name = pkg.name || basename(root);
+    const name = pkg.name || await resolveRepoName(root);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     // Detect monorepo
     const isMonorepo = !!(pkg.workspaces || await fileExists(join(root, "pnpm-workspace.yaml")));
@@ -212,11 +212,11 @@ async function detectFrameworks(root, pkg) {
         frameworks.push("django");
     // Go frameworks - check go.mod
     const goDeps = await getGoDeps(root);
-    if (goDeps.includes("net/http"))
+    if (goDeps.some((d) => d.includes("net/http")))
         frameworks.push("go-net-http");
-    if (goDeps.includes("gin-gonic/gin"))
+    if (goDeps.some((d) => d.includes("gin-gonic/gin")))
         frameworks.push("gin");
-    if (goDeps.includes("gofiber/fiber"))
+    if (goDeps.some((d) => d.includes("gofiber/fiber")))
         frameworks.push("fiber");
     if (goDeps.some((d) => d.includes("labstack/echo")))
         frameworks.push("echo");
@@ -429,6 +429,33 @@ async function getGoDeps(root) {
     catch { }
     return deps;
 }
+/**
+ * Resolve the repo name, handling git worktrees.
+ * In a worktree, basename(root) is a random name — resolve the actual repo instead.
+ */
+async function resolveRepoName(root) {
+    try {
+        // Check if .git is a file (worktree) vs directory (normal repo)
+        const gitPath = join(root, ".git");
+        const gitStat = await stat(gitPath);
+        if (gitStat.isFile()) {
+            // Worktree: .git is a file containing "gitdir: /path/to/main/.git/worktrees/name"
+            const gitContent = await readFile(gitPath, "utf-8");
+            const gitdirMatch = gitContent.match(/gitdir:\s*(.+)/);
+            if (gitdirMatch) {
+                // Resolve back to main repo: /repo/.git/worktrees/name -> /repo
+                const worktreeGitDir = gitdirMatch[1].trim();
+                // Go up from .git/worktrees/name to the repo root
+                const mainGitDir = join(worktreeGitDir, "..", "..");
+                const mainRepoRoot = join(mainGitDir, "..");
+                return basename(mainRepoRoot);
+            }
+        }
+    }
+    catch { }
+    // Fallback: use directory name
+    return basename(root);
+}
 async function fileExists(path) {
     try {
         await stat(path);

package/eval/fixtures/gin-gorm/ground-truth.json

@@ -0,0 +1,25 @@
+{
+  "routes": [
+    { "method": "GET", "path": "/health" },
+    { "method": "GET", "path": "/api/users" },
+    { "method": "GET", "path": "/api/users/:id" },
+    { "method": "POST", "path": "/api/users" },
+    { "method": "PUT", "path": "/api/users/:id" },
+    { "method": "DELETE", "path": "/api/users/:id" },
+    { "method": "GET", "path": "/api/projects" },
+    { "method": "GET", "path": "/api/projects/:id" },
+    { "method": "POST", "path": "/api/projects" }
+  ],
+  "models": [
+    {
+      "name": "User",
+      "fields": ["ID", "CreatedAt", "UpdatedAt", "DeletedAt", "Email", "Password", "Name", "Role"]
+    },
+    {
+      "name": "Project",
+      "fields": ["ID", "CreatedAt", "UpdatedAt", "DeletedAt", "Name", "Description", "IsPublic", "OwnerID"]
+    }
+  ],
+  "envVars": ["DATABASE_URL", "JWT_SECRET", "PORT", "GIN_MODE"],
+  "middleware": ["auth"]
+}

package/eval/fixtures/gin-gorm/repo.json

@@ -0,0 +1,16 @@
+{
+  "name": "gin-gorm-api",
+  "description": "Gin REST API with GORM models and route groups",
+  "files": {
+    "go.mod": "module github.com/example/api\n\ngo 1.22\n\nrequire (\n\tgithub.com/gin-gonic/gin v1.9.1\n\tgorm.io/gorm v1.25.5\n\tgorm.io/driver/postgres v1.5.4\n)",
+    ".env.example": "DATABASE_URL=postgres://localhost:5432/ginapi\nJWT_SECRET=changeme\nPORT=8080\nGIN_MODE=release",
+    "main.go": "package main\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n\t\"github.com/example/api/handlers\"\n\t\"github.com/example/api/middleware\"\n)\n\nfunc main() {\n\tr := gin.Default()\n\n\tr.GET(\"/health\", handlers.Health)\n\n\tapi := r.Group(\"/api\")\n\tapi.Use(middleware.Auth())\n\n\tusers := api.Group(\"/users\")\n\tusers.GET(\"\", handlers.ListUsers)\n\tusers.GET(\"/:id\", handlers.GetUser)\n\tusers.POST(\"\", handlers.CreateUser)\n\tusers.PUT(\"/:id\", handlers.UpdateUser)\n\tusers.DELETE(\"/:id\", handlers.DeleteUser)\n\n\tprojects := api.Group(\"/projects\")\n\tprojects.GET(\"\", handlers.ListProjects)\n\tprojects.GET(\"/:id\", handlers.GetProject)\n\tprojects.POST(\"\", handlers.CreateProject)\n\n\tr.Run(\":8080\")\n}",
+    "models/user.go": "package models\n\nimport (\n\t\"gorm.io/gorm\"\n\t\"time\"\n)\n\ntype User struct {\n\tgorm.Model\n\tEmail     string    `gorm:\"uniqueIndex;not null\" json:\"email\"`\n\tPassword  string    `gorm:\"not null\" json:\"-\"`\n\tName      string    `json:\"name\"`\n\tRole      string    `gorm:\"default:user\" json:\"role\"`\n\tProjects  []Project `gorm:\"foreignKey:OwnerID\" json:\"projects,omitempty\"`\n}",
+    "models/project.go": "package models\n\nimport (\n\t\"gorm.io/gorm\"\n)\n\ntype Project struct {\n\tgorm.Model\n\tName        string `gorm:\"not null\" json:\"name\"`\n\tDescription string `json:\"description\"`\n\tIsPublic    bool   `gorm:\"default:true\" json:\"is_public\"`\n\tOwnerID     uint   `gorm:\"not null;index\" json:\"owner_id\"`\n\tOwner       *User  `gorm:\"foreignKey:OwnerID\" json:\"owner,omitempty\"`\n}",
+    "handlers/health.go": "package handlers\n\nimport \"github.com/gin-gonic/gin\"\n\nfunc Health(c *gin.Context) {\n\tc.JSON(200, gin.H{\"status\": \"ok\"})\n}",
+    "handlers/users.go": "package handlers\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n\t\"github.com/example/api/models\"\n)\n\nfunc ListUsers(c *gin.Context) {\n\tvar users []models.User\n\tc.JSON(200, users)\n}\n\nfunc GetUser(c *gin.Context) {\n\tc.JSON(200, gin.H{})\n}\n\nfunc CreateUser(c *gin.Context) {\n\tc.JSON(201, gin.H{})\n}\n\nfunc UpdateUser(c *gin.Context) {\n\tc.JSON(200, gin.H{})\n}\n\nfunc DeleteUser(c *gin.Context) {\n\tc.JSON(200, gin.H{\"deleted\": true})\n}",
+    "handlers/projects.go": "package handlers\n\nimport (\n\t\"github.com/gin-gonic/gin\"\n)\n\nfunc ListProjects(c *gin.Context) {\n\tc.JSON(200, gin.H{})\n}\n\nfunc GetProject(c *gin.Context) {\n\tc.JSON(200, gin.H{})\n}\n\nfunc CreateProject(c *gin.Context) {\n\tc.JSON(201, gin.H{})\n}",
+    "middleware/auth.go": "package middleware\n\nimport \"github.com/gin-gonic/gin\"\n\nfunc Auth() gin.HandlerFunc {\n\treturn func(c *gin.Context) {\n\t\ttoken := c.GetHeader(\"Authorization\")\n\t\tif token == \"\" {\n\t\t\tc.AbortWithStatusJSON(401, gin.H{\"error\": \"unauthorized\"})\n\t\t\treturn\n\t\t}\n\t\tc.Next()\n\t}\n}",
+    "db/db.go": "package db\n\nimport (\n\t\"gorm.io/driver/postgres\"\n\t\"gorm.io/gorm\"\n\t\"os\"\n)\n\nvar DB *gorm.DB\n\nfunc Init() {\n\tdsn := os.Getenv(\"DATABASE_URL\")\n\tdb, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\tDB = db\n}"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codesight",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "See your codebase clearly. Universal AI context generator that maps routes, schema, components, dependencies, and more for Claude Code, Cursor, Copilot, Codex, and any AI coding tool.",
   "main": "dist/index.js",
   "bin": {