@thoughtflow/core 0.1.2

package/dist/libs/resource-decoder.class.js

@@ -0,0 +1,713 @@
+"use strict";
+/**
+ * ResourceDecoder — Pattern-based structural extraction for non-code resources.
+ *
+ * Detects and extracts structure from: SQL schemas, Prisma models, Dockerfiles,
+ * OpenAPI specs, GraphQL schemas, Protobuf definitions, YAML configs
+ * (docker-compose, k8s, CI), and migration files.
+ *
+ * Follows the same StructuralDecoder interface as code decoders.
+ * Auto-detects resource type by extension + content heuristics.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceDecoder = void 0;
+const crypto_1 = require("crypto");
+// ── SQL ─────────────────────────────────────────────────────────────────────
+function extractSqlSymbols(content, lines) {
+    const symbols = [];
+    // Tables: CREATE TABLE [IF NOT EXISTS] name
+    const tableRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|')?(\w+)(?:`|"|')?\s*\(/gi;
+    for (const m of content.matchAll(tableRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingParen(lines, line - 1);
+        const columns = extractSqlColumns(content, m.index, endLine, lines);
+        symbols.push({
+            name: m[1],
+            kind: "table",
+            startLine: line,
+            endLine,
+            exported: true,
+            members: columns,
+        });
+    }
+    // Indexes: CREATE [UNIQUE] INDEX name ON table
+    const indexRe = /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|"|')?(\w+)(?:`|"|')?\s+ON\s+(?:`|"|')?(\w+)/gi;
+    for (const m of content.matchAll(indexRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: m[1],
+            kind: "index",
+            startLine: line,
+            endLine: line,
+            exported: true,
+            extends: m[2], // table it belongs to
+        });
+    }
+    // Views: CREATE [OR REPLACE] VIEW name
+    const viewRe = /CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+(?:`|"|')?(\w+)/gi;
+    for (const m of content.matchAll(viewRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: m[1],
+            kind: "table", // treat as table-like
+            startLine: line,
+            endLine: line,
+            exported: true,
+        });
+    }
+    return symbols;
+}
+function extractSqlColumns(content, tableStart, tableEndLine, lines) {
+    const cols = [];
+    const startLine = getLineNumber(content, tableStart);
+    for (let i = startLine; i < tableEndLine && i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        // Skip CREATE TABLE line, constraints, empty lines, closing paren
+        if (/^(CREATE|PRIMARY|UNIQUE|FOREIGN|CHECK|CONSTRAINT|INDEX|\)|--|\s*$)/i.test(trimmed))
+            continue;
+        const colMatch = trimmed.match(/^(?:`|"|')?(\w+)(?:`|"|')?\s+(\w+)/);
+        if (colMatch) {
+            cols.push({
+                name: colMatch[1],
+                kind: "column",
+                startLine: i + 1,
+                endLine: i + 1,
+                exported: true,
+                typeAnnotation: colMatch[2],
+            });
+        }
+    }
+    return cols;
+}
+// ── Prisma ──────────────────────────────────────────────────────────────────
+function extractPrismaSymbols(content, lines) {
+    const symbols = [];
+    // model Name { ... }
+    const modelRe = /^model\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(modelRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        const fields = extractPrismaFields(lines, line, endLine);
+        symbols.push({
+            name: m[1],
+            kind: "model",
+            startLine: line,
+            endLine,
+            exported: true,
+            members: fields,
+        });
+    }
+    // enum Name { ... }
+    const enumRe = /^enum\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(enumRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: "enum",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    // datasource / generator blocks
+    const blockRe = /^(datasource|generator)\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(blockRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[2],
+            kind: "variable",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    return symbols;
+}
+function extractPrismaFields(lines, startLine, endLine) {
+    const fields = [];
+    for (let i = startLine; i < endLine && i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@") || trimmed === "}")
+            continue;
+        const fieldMatch = trimmed.match(/^(\w+)\s+(\S+)/);
+        if (fieldMatch) {
+            const isRelation = /\brelation\b/.test(trimmed);
+            fields.push({
+                name: fieldMatch[1],
+                kind: isRelation ? "relation" : "field",
+                startLine: i + 1,
+                endLine: i + 1,
+                exported: true,
+                typeAnnotation: fieldMatch[2],
+            });
+        }
+    }
+    return fields;
+}
+function extractPrismaImports(content) {
+    // Prisma doesn't have traditional imports, but datasource provider is a dependency
+    const imports = [];
+    const providerRe = /provider\s*=\s*"([^"]+)"/g;
+    for (const m of content.matchAll(providerRe)) {
+        imports.push({
+            source: m[1],
+            names: null,
+            isDefault: false,
+            isNamespace: false,
+            isTypeOnly: false,
+            line: getLineNumber(content, m.index),
+        });
+    }
+    return imports;
+}
+// ── Docker ──────────────────────────────────────────────────────────────────
+function extractDockerSymbols(content, lines) {
+    const symbols = [];
+    // FROM image:tag [AS alias]
+    const fromRe = /^FROM\s+(\S+)(?:\s+AS\s+(\w+))?/gim;
+    for (const m of content.matchAll(fromRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: m[2] || m[1],
+            kind: "container",
+            startLine: line,
+            endLine: line,
+            exported: true,
+            extends: m[1],
+        });
+    }
+    // EXPOSE port
+    const exposeRe = /^EXPOSE\s+(.+)/gim;
+    for (const m of content.matchAll(exposeRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: `port:${m[1].trim()}`,
+            kind: "endpoint",
+            startLine: line,
+            endLine: line,
+            exported: true,
+        });
+    }
+    // ENV key=value
+    const envRe = /^ENV\s+(\w+)[= ]/gim;
+    for (const m of content.matchAll(envRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: m[1],
+            kind: "env_var",
+            startLine: line,
+            endLine: line,
+            exported: true,
+        });
+    }
+    // VOLUME
+    const volumeRe = /^VOLUME\s+(.+)/gim;
+    for (const m of content.matchAll(volumeRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: m[1].trim().replace(/[\[\]"]/g, ""),
+            kind: "volume",
+            startLine: line,
+            endLine: line,
+            exported: true,
+        });
+    }
+    return symbols;
+}
+// ── Docker Compose / Kubernetes YAML ────────────────────────────────────────
+function extractComposeSymbols(content, lines) {
+    const symbols = [];
+    // docker-compose services
+    const inServices = findYamlSection(lines, "services");
+    if (inServices) {
+        const { startLine, endLine } = inServices;
+        let currentService = null;
+        let serviceStart = 0;
+        for (let i = startLine; i <= endLine && i < lines.length; i++) {
+            const line = lines[i];
+            // Service names are at indent level 2 (2 spaces under services)
+            const svcMatch = line.match(/^  (\w[\w.-]+)\s*:/);
+            if (svcMatch) {
+                if (currentService) {
+                    symbols.push({
+                        name: currentService,
+                        kind: "service",
+                        startLine: serviceStart + 1,
+                        endLine: i,
+                        exported: true,
+                    });
+                }
+                currentService = svcMatch[1];
+                serviceStart = i;
+            }
+        }
+        if (currentService) {
+            symbols.push({
+                name: currentService,
+                kind: "service",
+                startLine: serviceStart + 1,
+                endLine: endLine + 1,
+                exported: true,
+            });
+        }
+    }
+    // docker-compose volumes (top-level)
+    const inVolumes = findYamlSection(lines, "volumes");
+    if (inVolumes) {
+        const { startLine, endLine } = inVolumes;
+        for (let i = startLine; i <= endLine && i < lines.length; i++) {
+            const volMatch = lines[i].match(/^  (\w[\w.-]+)\s*:/);
+            if (volMatch) {
+                symbols.push({
+                    name: volMatch[1],
+                    kind: "volume",
+                    startLine: i + 1,
+                    endLine: i + 1,
+                    exported: true,
+                });
+            }
+        }
+    }
+    return symbols;
+}
+function extractK8sSymbols(content, lines) {
+    const symbols = [];
+    // Multi-document YAML (--- separated)
+    const docs = content.split(/^---$/m);
+    let lineOffset = 0;
+    for (const doc of docs) {
+        const kindMatch = doc.match(/^kind:\s*(\w+)/m);
+        const nameMatch = doc.match(/^\s+name:\s*(\S+)/m);
+        if (kindMatch) {
+            const docLines = doc.split("\n");
+            symbols.push({
+                name: nameMatch?.[1] ?? kindMatch[1],
+                kind: "service",
+                startLine: lineOffset + 1,
+                endLine: lineOffset + docLines.length,
+                exported: true,
+                typeAnnotation: kindMatch[1],
+            });
+        }
+        lineOffset += doc.split("\n").length;
+    }
+    return symbols;
+}
+// ── OpenAPI ─────────────────────────────────────────────────────────────────
+function extractOpenApiSymbols(content, lines) {
+    const symbols = [];
+    // YAML-style paths (indented under paths:)
+    const pathsSection = findYamlSection(lines, "paths");
+    if (pathsSection) {
+        for (let i = pathsSection.startLine; i <= pathsSection.endLine && i < lines.length; i++) {
+            // Path entries at indent level 2 under paths:
+            const pathMatch = lines[i].match(/^  (\/\S+)\s*:/);
+            if (pathMatch) {
+                symbols.push({
+                    name: pathMatch[1],
+                    kind: "endpoint",
+                    startLine: i + 1,
+                    endLine: i + 1,
+                    exported: true,
+                });
+            }
+        }
+    }
+    // JSON-style endpoints from paths object
+    const jsonPathRe = /"(\/[^"]+)"\s*:\s*\{/g;
+    for (const m of content.matchAll(jsonPathRe)) {
+        const line = getLineNumber(content, m.index);
+        // Skip if it's a $ref or schema path
+        if (m[1].startsWith("/$"))
+            continue;
+        symbols.push({
+            name: m[1],
+            kind: "endpoint",
+            startLine: line,
+            endLine: line,
+            exported: true,
+        });
+    }
+    // Components/schemas — nested under components: → schemas:
+    // Find "schemas:" that is indented (under components)
+    for (let i = 0; i < lines.length; i++) {
+        const schemasMatch = lines[i].match(/^(\s+)schemas\s*:/);
+        if (schemasMatch) {
+            const baseIndent = schemasMatch[1].length;
+            const schemaIndent = baseIndent + 2;
+            for (let j = i + 1; j < lines.length; j++) {
+                const trimmed = lines[j].trimStart();
+                const currentIndent = lines[j].length - trimmed.length;
+                if (currentIndent <= baseIndent && trimmed.length > 0)
+                    break;
+                if (currentIndent === schemaIndent && trimmed.match(/^(\w+)\s*:/)) {
+                    const schemaName = trimmed.match(/^(\w+)\s*:/)[1];
+                    symbols.push({
+                        name: schemaName,
+                        kind: "model",
+                        startLine: j + 1,
+                        endLine: j + 1,
+                        exported: true,
+                    });
+                }
+            }
+            break;
+        }
+    }
+    return symbols;
+}
+// ── GraphQL ─────────────────────────────────────────────────────────────────
+function extractGraphqlSymbols(content, lines) {
+    const symbols = [];
+    // type Name { ... }
+    const typeRe = /^type\s+(\w+)(?:\s+implements\s+([^{]+))?\s*\{/gm;
+    for (const m of content.matchAll(typeRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: m[1] === "Query" || m[1] === "Mutation" || m[1] === "Subscription"
+                ? "route"
+                : "model",
+            startLine: line,
+            endLine,
+            exported: true,
+            implements: m[2]?.split("&").map((s) => s.trim()).filter(Boolean),
+        });
+    }
+    // input Name { ... }
+    const inputRe = /^input\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(inputRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: "model",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    // enum Name { ... }
+    const enumRe = /^enum\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(enumRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: "enum",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    // scalar Name
+    const scalarRe = /^scalar\s+(\w+)/gm;
+    for (const m of content.matchAll(scalarRe)) {
+        const line = getLineNumber(content, m.index);
+        symbols.push({
+            name: m[1],
+            kind: "type",
+            startLine: line,
+            endLine: line,
+            exported: true,
+        });
+    }
+    return symbols;
+}
+// ── Protobuf ────────────────────────────────────────────────────────────────
+function extractProtoSymbols(content, lines) {
+    const symbols = [];
+    // message Name { ... }
+    const msgRe = /^message\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(msgRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: "message",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    // service Name { rpc ... }
+    const svcRe = /^service\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(svcRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: "service",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    // enum Name { ... }
+    const enumRe = /^enum\s+(\w+)\s*\{/gm;
+    for (const m of content.matchAll(enumRe)) {
+        const line = getLineNumber(content, m.index);
+        const endLine = findClosingBrace(lines, line - 1);
+        symbols.push({
+            name: m[1],
+            kind: "enum",
+            startLine: line,
+            endLine,
+            exported: true,
+        });
+    }
+    return symbols;
+}
+function extractProtoImports(content) {
+    const imports = [];
+    const importRe = /^import\s+"([^"]+)"\s*;/gm;
+    for (const m of content.matchAll(importRe)) {
+        imports.push({
+            source: m[1],
+            names: null,
+            isDefault: false,
+            isNamespace: false,
+            isTypeOnly: false,
+            line: getLineNumber(content, m.index),
+        });
+    }
+    return imports;
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function getLineNumber(content, charIndex) {
+    let line = 1;
+    for (let i = 0; i < charIndex && i < content.length; i++) {
+        if (content[i] === "\n")
+            line++;
+    }
+    return line;
+}
+function findClosingBrace(lines, startIdx) {
+    let depth = 0;
+    for (let i = startIdx; i < lines.length; i++) {
+        for (const ch of lines[i]) {
+            if (ch === "{")
+                depth++;
+            if (ch === "}") {
+                depth--;
+                if (depth <= 0)
+                    return i + 1;
+            }
+        }
+    }
+    return lines.length;
+}
+function findClosingParen(lines, startIdx) {
+    let depth = 0;
+    for (let i = startIdx; i < lines.length; i++) {
+        for (const ch of lines[i]) {
+            if (ch === "(")
+                depth++;
+            if (ch === ")") {
+                depth--;
+                if (depth <= 0)
+                    return i + 1;
+            }
+        }
+    }
+    return lines.length;
+}
+function findYamlSection(lines, sectionName) {
+    for (let i = 0; i < lines.length; i++) {
+        if (new RegExp(`^${sectionName}\\s*:`).test(lines[i])) {
+            const startLine = i + 1;
+            let endLine = lines.length - 1;
+            // Find next top-level key (no indent)
+            for (let j = startLine; j < lines.length; j++) {
+                if (/^\S/.test(lines[j]) && lines[j].trim() !== "") {
+                    endLine = j - 1;
+                    break;
+                }
+            }
+            return { startLine, endLine };
+        }
+    }
+    return null;
+}
+// ── Content-based Resource Classifier ───────────────────────────────────────
+function classifyYaml(content) {
+    if (/^services\s*:/m.test(content) && /^version\s*:|^services\s*:/m.test(content))
+        return "compose";
+    if (/^apiVersion\s*:/m.test(content) && /^kind\s*:/m.test(content))
+        return "k8s";
+    if (/^openapi\s*:|^swagger\s*:/m.test(content))
+        return "openapi";
+    return "config";
+}
+function classifyJson(content) {
+    try {
+        const obj = JSON.parse(content);
+        if (obj.openapi || obj.swagger)
+            return "openapi";
+    }
+    catch { /* not valid JSON — ignore */ }
+    return "config";
+}
+// ── Resource Pattern Registry ───────────────────────────────────────────────
+const RESOURCE_PATTERNS = [
+    {
+        id: "sql",
+        language: "sql",
+        resourceKind: "schema",
+        extensions: [".sql"],
+        extractSymbols: extractSqlSymbols,
+    },
+    {
+        id: "prisma",
+        language: "prisma",
+        resourceKind: "schema",
+        extensions: [".prisma"],
+        extractSymbols: extractPrismaSymbols,
+        extractImports: extractPrismaImports,
+    },
+    {
+        id: "dockerfile",
+        language: "dockerfile",
+        resourceKind: "infra",
+        extensions: [], // handled by filename match
+        extractSymbols: extractDockerSymbols,
+    },
+    {
+        id: "graphql",
+        language: "graphql",
+        resourceKind: "api-spec",
+        extensions: [".graphql", ".gql"],
+        extractSymbols: extractGraphqlSymbols,
+    },
+    {
+        id: "protobuf",
+        language: "protobuf",
+        resourceKind: "api-spec",
+        extensions: [".proto"],
+        extractSymbols: extractProtoSymbols,
+        extractImports: extractProtoImports,
+    },
+];
+// ── ResourceDecoder Class ───────────────────────────────────────────────────
+class ResourceDecoder {
+    name = "resource";
+    supportedExtensions;
+    supportedLanguages;
+    constructor() {
+        const exts = new Set();
+        for (const p of RESOURCE_PATTERNS) {
+            for (const ext of p.extensions)
+                exts.add(ext);
+        }
+        // Also handle YAML, JSON, and Dockerfile patterns
+        exts.add(".yaml");
+        exts.add(".yml");
+        exts.add(".json");
+        this.supportedExtensions = [...exts];
+        this.supportedLanguages = RESOURCE_PATTERNS.map((p) => p.language);
+    }
+    canDecode(filePath, content) {
+        const name = filePath.split("/").pop() ?? "";
+        const ext = this.getExtension(filePath);
+        // Direct extension match
+        if (RESOURCE_PATTERNS.some((p) => p.extensions.includes(ext)))
+            return true;
+        // Dockerfile (by name)
+        if (/^Dockerfile/i.test(name) || /\.dockerfile$/i.test(name))
+            return true;
+        // YAML — only if it looks like a resource (compose, k8s, openapi)
+        if (ext === ".yaml" || ext === ".yml") {
+            if (!content)
+                return true; // optimistic — will classify in decode()
+            const kind = classifyYaml(content);
+            return kind !== "config"; // skip generic config files
+        }
+        // JSON — only if it's OpenAPI / Swagger
+        if (ext === ".json") {
+            if (!content)
+                return false;
+            return classifyJson(content) === "openapi";
+        }
+        return false;
+    }
+    decode(filePath, content, _projectRoot) {
+        const contentHash = (0, crypto_1.createHash)("sha256").update(content).digest("hex");
+        const lines = content.split("\n");
+        const totalLines = lines.length;
+        const ext = this.getExtension(filePath);
+        const name = filePath.split("/").pop() ?? "";
+        const { pattern, language, resourceKind } = this.resolvePattern(ext, name, content);
+        const symbols = pattern?.extractSymbols(content, lines) ?? [];
+        const imports = pattern?.extractImports?.(content) ?? [];
+        return {
+            filePath,
+            language,
+            totalLines,
+            symbols,
+            imports,
+            exports: [],
+            contentHash,
+            decodedAt: new Date().toISOString(),
+            decoderName: this.name,
+            resourceKind,
+        };
+    }
+    // ── Private ───────────────────────────────────────────────────────────
+    resolvePattern(ext, fileName, content) {
+        // Direct extension match
+        const direct = RESOURCE_PATTERNS.find((p) => p.extensions.includes(ext));
+        if (direct)
+            return { pattern: direct, language: direct.language, resourceKind: direct.resourceKind };
+        // Dockerfile
+        if (/^Dockerfile/i.test(fileName) || /\.dockerfile$/i.test(fileName)) {
+            const p = RESOURCE_PATTERNS.find((r) => r.id === "dockerfile");
+            return { pattern: p, language: "dockerfile", resourceKind: "infra" };
+        }
+        // YAML classification
+        if (ext === ".yaml" || ext === ".yml") {
+            const kind = classifyYaml(content);
+            switch (kind) {
+                case "compose":
+                    return {
+                        pattern: { id: "compose", language: "docker-compose", resourceKind: "infra", extensions: [], extractSymbols: extractComposeSymbols },
+                        language: "docker-compose",
+                        resourceKind: "infra",
+                    };
+                case "k8s":
+                    return {
+                        pattern: { id: "k8s", language: "kubernetes", resourceKind: "infra", extensions: [], extractSymbols: extractK8sSymbols },
+                        language: "kubernetes",
+                        resourceKind: "infra",
+                    };
+                case "openapi":
+                    return {
+                        pattern: { id: "openapi-yaml", language: "openapi", resourceKind: "api-spec", extensions: [], extractSymbols: extractOpenApiSymbols },
+                        language: "openapi",
+                        resourceKind: "api-spec",
+                    };
+                default:
+                    return { pattern: null, language: "yaml", resourceKind: "config" };
+            }
+        }
+        // JSON OpenAPI
+        if (ext === ".json") {
+            if (classifyJson(content) === "openapi") {
+                return {
+                    pattern: { id: "openapi-json", language: "openapi", resourceKind: "api-spec", extensions: [], extractSymbols: extractOpenApiSymbols },
+                    language: "openapi",
+                    resourceKind: "api-spec",
+                };
+            }
+        }
+        return { pattern: null, language: "unknown", resourceKind: "config" };
+    }
+    getExtension(filePath) {
+        const parts = filePath.split(".");
+        return parts.length > 1 ? `.${parts[parts.length - 1]}` : "";
+    }
+}
+exports.ResourceDecoder = ResourceDecoder;
+//# sourceMappingURL=resource-decoder.class.js.map