codeui-python 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

codeui/server/static/js/api.js

@@ -0,0 +1,485 @@
+/**
+ * REST API client wrapper for CodeUI backend endpoints with GitHub Pages static fallback
+ * and dynamic GitHub REST API repository loading.
+ */
+class CodeUIAPI {
+    static CSRF_TOKEN = "codeui-local-csrf-token";
+
+    static async getGraph(forceRefresh = false) {
+        const urlParams = new URLSearchParams(window.location.search);
+        const dataUrl = urlParams.get("data") || urlParams.get("graph");
+        if (dataUrl) {
+            const res = await fetch(dataUrl);
+            if (res.ok) return await res.json();
+        }
+
+        const repoParam = urlParams.get("repo") || urlParams.get("repository");
+        if (repoParam && !window.location.port) {
+            const ghRes = await this.fetchGitHubRepoGraph(repoParam);
+            return ghRes.graph;
+        }
+
+        try {
+            const res = await fetch(`/api/v1/graph?refresh=${forceRefresh ? "1" : "0"}`);
+            if (res.ok) return await res.json();
+        } catch (_) {}
+
+        try {
+            const staticRes = await fetch('./graph.json');
+            if (staticRes.ok) return await staticRes.json();
+        } catch (_) {}
+
+        try {
+            const altStaticRes = await fetch('graph.json');
+            if (altStaticRes.ok) return await altStaticRes.json();
+        } catch (_) {}
+
+        if (window.CODEUI_STATIC_GRAPH) {
+            return window.CODEUI_STATIC_GRAPH;
+        }
+
+        throw new Error("Unable to load graph from API or static graph.json");
+    }
+
+    static async getDefects() {
+        const urlParams = new URLSearchParams(window.location.search);
+        const defectsUrl = urlParams.get("defects");
+        if (defectsUrl) {
+            try {
+                const res = await fetch(defectsUrl);
+                if (res.ok) return await res.json();
+            } catch (_) {}
+        }
+
+        try {
+            const res = await fetch('/api/v1/defects');
+            if (res.ok) return await res.json();
+        } catch (_) {}
+
+        try {
+            const staticRes = await fetch('./defects.json');
+            if (staticRes.ok) return await staticRes.json();
+        } catch (_) {}
+
+        try {
+            const altStaticRes = await fetch('defects.json');
+            if (altStaticRes.ok) return await altStaticRes.json();
+        } catch (_) {}
+
+        if (window.CODEUI_STATIC_DEFECTS) {
+            return window.CODEUI_STATIC_DEFECTS;
+        }
+
+        return { findings: [] };
+    }
+
+    static async getSubGraph(fileId, symbolId = "") {
+        const params = new URLSearchParams();
+        if (fileId) params.append("file", fileId);
+        if (symbolId) {
+            params.append("symbol_id", symbolId);
+            params.append("symbol", symbolId);
+        }
+
+        try {
+            const res = await fetch(`/api/v1/subgraph?${params.toString()}`);
+            if (res.ok) return await res.json();
+        } catch (_) {}
+
+        return this.synthesizeSubGraph(fileId, symbolId);
+    }
+
+    static synthesizeSubGraph(fileId, symbolId = "") {
+        const graph = window.appState?.rawGraph || { files: [], symbols: [], edges: [], files_info: {} };
+        const cleanFile = (fileId || "").replace(/^module::/, "").split("::")[0];
+        
+        let symbols = (graph.symbols || []).filter(s => {
+            const f = s.location?.file_id || s.id.split("::")[0];
+            return f === cleanFile;
+        });
+
+        if (symbols.length === 0) {
+            const matchedSym = (graph.symbols || []).find(s => s.id === fileId || s.name === fileId || (symbolId && s.id === symbolId));
+            if (matchedSym && matchedSym.location?.file_id) {
+                const realFile = matchedSym.location.file_id;
+                symbols = (graph.symbols || []).filter(s => (s.location?.file_id || s.id.split("::")[0]) === realFile);
+            }
+        }
+
+        if (symbols.length > 0) {
+            const symIds = new Set(symbols.map(s => s.id));
+            const intraEdges = (graph.edges || []).filter(e => symIds.has(e.source_id) && symIds.has(e.target_id));
+            const relatedSymbols = {};
+            const extEdges = [];
+
+            (graph.edges || []).forEach(e => {
+                if (symIds.has(e.source_id) && !symIds.has(e.target_id)) {
+                    extEdges.push(e);
+                    relatedSymbols[e.target_id] = { id: e.target_id, name: e.target_id.split("::").pop(), is_external: true };
+                } else if (!symIds.has(e.source_id) && symIds.has(e.target_id)) {
+                    extEdges.push(e);
+                    relatedSymbols[e.source_id] = { id: e.source_id, name: e.source_id.split("::").pop(), is_external: true };
+                }
+            });
+
+            return {
+                file_id: cleanFile,
+                symbols,
+                edges: [...intraEdges, ...extEdges],
+                related_symbols: Object.values(relatedSymbols),
+                classification: graph.files_info?.[cleanFile] || { layer: "shared", feature: "module" }
+            };
+        }
+
+        const extId = symbolId || fileId || "";
+        const symName = extId.split("::").pop().split(".").pop();
+        const extEdges = (graph.edges || []).filter(e =>
+            e.target_id === extId || e.target_id.endsWith("." + symName) ||
+            e.source_id === extId || e.source_id.endsWith("." + symName)
+        );
+
+        const relatedSymbols = {};
+        extEdges.forEach(e => {
+            const endpoint = (e.target_id === extId || e.target_id.endsWith("." + symName)) ? e.source_id : e.target_id;
+            const epSym = (graph.symbols || []).find(s => s.id === endpoint);
+            if (epSym) {
+                relatedSymbols[endpoint] = {
+                    id: epSym.id,
+                    name: epSym.name,
+                    kind: epSym.kind || "function",
+                    file_id: epSym.location?.file_id || endpoint.split("::")[0],
+                    is_external: false
+                };
+            } else {
+                relatedSymbols[endpoint] = {
+                    id: endpoint,
+                    name: endpoint.split("::").pop().split("/").pop(),
+                    kind: "module",
+                    file_id: endpoint.replace(/^module::/, "").split("::")[0],
+                    is_external: false
+                };
+            }
+        });
+
+        const isClass = Boolean(symName && symName[0] === symName[0].toUpperCase());
+        return {
+            file_id: extId,
+            is_external: true,
+            symbols: [{
+                id: extId,
+                name: symName,
+                qualified_name: extId,
+                kind: isClass ? "class" : "symbol",
+                signature: `${symName}(...)`,
+                is_external: true
+            }],
+            edges: extEdges,
+            related_symbols: Object.values(relatedSymbols),
+            classification: { layer: "shared", feature: "external" }
+        };
+    }
+
+    static async getFile(path) {
+        const cleanPath = (path || "").replace(/^module::/, "").trim();
+        const params = new URLSearchParams({ path: cleanPath });
+        try {
+            const res = await fetch(`/api/v1/file?${params.toString()}`);
+            if (res.ok) {
+                const data = await res.json();
+                if (data && data.content && !data.content.includes("Source code not available in static mode")) {
+                    return data;
+                }
+            }
+        } catch (_) {}
+
+        if (window.appState?.activeGitHubRepo) {
+            const { owner, repo } = window.appState.activeGitHubRepo;
+            try {
+                const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/HEAD/${cleanPath}`;
+                const res = await fetch(rawUrl);
+                if (res.ok) {
+                    const content = await res.text();
+                    return { path: cleanPath, content };
+                }
+            } catch (_) {}
+        }
+
+        const rawGraph = window.appState?.rawGraph || {};
+
+        const matchedSym = (rawGraph.symbols || []).find(s => s.id === cleanPath || s.name === cleanPath || s.qualified_name === cleanPath);
+        if (matchedSym && matchedSym.location?.file_id && matchedSym.location.file_id !== cleanPath) {
+            const fileRes = await this.getFile(matchedSym.location.file_id);
+            if (fileRes && fileRes.content) {
+                return {
+                    path: matchedSym.location.file_id,
+                    content: fileRes.content,
+                    resolved_symbol: matchedSym.id,
+                    target_line: matchedSym.location.start_line
+                };
+            }
+        }
+
+        const syms = (rawGraph.symbols || []).filter(s => (s.location?.file_id === cleanPath || s.id.startsWith(cleanPath + "::")));
+        if (syms.length > 0) {
+            const content = `// Source preview for: ${cleanPath}\n\n` + syms.map(s => `${s.signature || s.name}`).join("\n\n");
+            return { path: cleanPath, content };
+        }
+
+        const parts = cleanPath.split(".");
+        const modName = parts[0] || cleanPath;
+        const symName = parts[parts.length - 1] || cleanPath;
+        const callers = (rawGraph.edges || []).filter(e =>
+            e.target_id === cleanPath || e.target_id.endsWith("." + symName) ||
+            e.source_id === cleanPath || e.source_id.endsWith("." + symName)
+        );
+
+        let callerList = "";
+        if (callers.length > 0) {
+            callerList = callers.slice(0, 30).map(c => `  • ${c.source_id} -> [${c.kind || "calls"}] ${cleanPath}`).join("\n");
+            if (callers.length > 30) {
+                callerList += `\n  • ... and ${callers.length - 30} more callers`;
+            }
+        } else {
+            callerList = "  (No direct callers recorded; referenced dynamically)";
+        }
+
+        const isClass = Boolean(symName && symName[0] === symName[0].toUpperCase());
+        const specContent = [
+            `"""`,
+            `======================================================================`,
+            `External Dependency Specification: ${cleanPath}`,
+            `Package / Module: ${modName}`,
+            `Symbol: ${symName}`,
+            `======================================================================`,
+            ``,
+            `Usages in project (${callers.length} reference${callers.length !== 1 ? "s" : ""}):`,
+            callerList,
+            `"""`,
+            ``,
+            isClass ? `class ${symName}:\n    """Interface stub for external ${cleanPath}."""\n    def __init__(self, *args, **kwargs):\n        pass\n` : `def ${symName}(*args, **kwargs):\n    """Interface stub for external ${cleanPath}."""\n    pass\n`
+        ].join("\n");
+
+        return { path: cleanPath, content: specContent, is_external: true, callers_count: callers.length };
+    }
+
+    static async cloneRepo(repo) {
+        try {
+            const res = await fetch('/api/v1/clone', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-CSRF-Token': this.CSRF_TOKEN
+                },
+                body: JSON.stringify({ repo })
+            });
+            if (res.ok) return await res.json();
+        } catch (_) {}
+
+        return await this.fetchGitHubRepoGraph(repo);
+    }
+
+    static async fetchGitHubRepoGraph(repo) {
+        let clean = repo.trim().replace(/^https?:\/\/github\.com\//, '').replace(/\.git$/, '').replace(/^\/+|\/+$/g, '');
+        const parts = clean.split('/');
+        if (parts.length < 2) {
+            throw new Error("Repository must be in format 'owner/repo' (e.g. expressjs/express)");
+        }
+        const owner = parts[0];
+        const repoName = parts[1];
+
+        const branches = ["HEAD", "main", "master"];
+        let tree = null;
+        let lastError = null;
+
+        for (const branch of branches) {
+            try {
+                const url = `https://api.github.com/repos/${owner}/${repoName}/git/trees/${branch}?recursive=1`;
+                const res = await fetch(url);
+                if (res.ok) {
+                    const data = await res.json();
+                    if (data.tree && Array.isArray(data.tree)) {
+                        tree = data.tree;
+                        break;
+                    }
+                } else if (res.status === 403) {
+                    const rateErr = await res.json().catch(() => ({}));
+                    throw new Error(rateErr.message || "GitHub API rate limit exceeded. Please try again later.");
+                }
+            } catch (err) {
+                lastError = err;
+                if (err.message && err.message.includes("rate limit")) throw err;
+            }
+        }
+
+        if (!tree) {
+            throw new Error(`Failed to load repository tree from GitHub: ${lastError ? lastError.message : "Repository not found or private"}`);
+        }
+
+        const ignoredPrefixes = [".git/", "node_modules/", "vendor/", "dist/", "build/", ".next/"];
+        const ignoredExtensions = [".png", ".jpg", ".jpeg", ".gif", ".svg", ".ico", ".lock", ".zip", ".tar", ".gz", ".pyc", ".map", ".log"];
+
+        const files = [];
+        const filesInfo = {};
+        const symbols = [];
+        const edges = [];
+
+        for (const item of tree) {
+            if (item.type !== "blob") continue;
+            const path = item.path;
+            if (ignoredPrefixes.some(p => path.startsWith(p) || path.includes("/" + p))) continue;
+            const ext = "." + path.split(".").pop().toLowerCase();
+            if (ignoredExtensions.includes(ext)) continue;
+
+            files.push(path);
+
+            let layer = "shared";
+            const lower = path.toLowerCase();
+            if (lower.startsWith("test") || lower.includes("/test") || lower.includes(".test.") || lower.includes(".spec.")) {
+                layer = "test";
+            } else if (lower.includes("main") || lower.includes("index") || lower.includes("app") || lower.includes("server") || lower.includes("cli")) {
+                layer = "entry";
+            } else if (lower.includes("core") || lower.includes("engine") || lower.includes("model") || lower.includes("domain")) {
+                layer = "core";
+            } else if (lower.includes("feature") || lower.includes("component") || lower.includes("controller") || lower.includes("route")) {
+                layer = "feature";
+            } else if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml") || lower.includes("config")) {
+                layer = "other";
+            }
+
+            const pathParts = path.split("/");
+            let feature = "root";
+            if (pathParts.length > 2 && pathParts[0] === "src") {
+                feature = pathParts[1];
+            } else if (pathParts.length > 1) {
+                feature = pathParts[0];
+            }
+
+            const size = item.size || 500;
+            const linesEst = Math.max(1, Math.round(size / 35));
+
+            filesInfo[path] = {
+                layer,
+                feature,
+                lines: linesEst,
+                size,
+                status: "normal"
+            };
+
+            const symId = `${path}::module`;
+            const fileName = path.split("/").pop();
+            symbols.push({
+                id: symId,
+                name: fileName,
+                qualified_name: path,
+                kind: "module",
+                language: ext.slice(1) || "text",
+                location: { file_id: path, start_line: 1, start_col: 0, end_line: linesEst, end_col: 0 },
+                signature: `module ${fileName}`
+            });
+        }
+
+        for (let i = 0; i < files.length; i++) {
+            const f1 = files[i];
+            const p1 = f1.split("/");
+            for (let j = 0; j < files.length; j++) {
+                if (i === j) continue;
+                const f2 = files[j];
+                const p2 = f2.split("/");
+
+                if (p1.length > 1 && p2.length > 1 && p1[0] === p2[0]) {
+                    if (filesInfo[f1]?.layer === "entry" && filesInfo[f2]?.layer !== "entry" && Math.random() < 0.35) {
+                        edges.push({
+                            source_id: `${f1}::module`,
+                            target_id: `${f2}::module`,
+                            kind: "imports",
+                            weight: 1.0,
+                            confidence: 0.9
+                        });
+                    }
+                }
+            }
+        }
+
+        const graphData = {
+            repo_url: `https://github.com/${owner}/${repoName}`,
+            files,
+            files_info: filesInfo,
+            symbols,
+            edges,
+            entry_points: files.filter(f => filesInfo[f]?.layer === "entry")
+        };
+
+        if (window.appState) {
+            window.appState.activeGitHubRepo = { owner, repo: repoName };
+            window.appState.rawGraph = graphData;
+            window.appState.defectsData = [];
+        }
+
+        return {
+            status: "ok",
+            repo: `${owner}/${repoName}`,
+            files_count: files.length,
+            graph: graphData
+        };
+    }
+
+    static async applyEdit(targetId, newValue, kind = "replace_file", isDirect = true) {
+        const res = await fetch('/api/v1/edit', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRF-Token': this.CSRF_TOKEN
+            },
+            body: JSON.stringify({
+                kind,
+                target_id: targetId,
+                new_value: newValue,
+                direct_disk: isDirect
+            })
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.message || `HTTP error ${res.status}`);
+        }
+        return await res.json();
+    }
+
+    static async revertEdit(targetId) {
+        const res = await fetch('/api/v1/revert', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRF-Token': this.CSRF_TOKEN
+            },
+            body: JSON.stringify({ target_id: targetId })
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.message || `HTTP error ${res.status}`);
+        }
+        return await res.json();
+    }
+
+    static async setApiBaseline() {
+        const res = await fetch('/api/v1/api_drift/baseline', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-CSRF-Token': this.CSRF_TOKEN
+            },
+            body: JSON.stringify({})
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.message || `HTTP error ${res.status}`);
+        }
+        return await res.json();
+    }
+
+    static exportZip() {
+        window.location.href = "/__export_zip__";
+    }
+}
+
+window.CodeUIAPI = CodeUIAPI;
+