vs-code-ext-from-any-js 1.15.4

package/src/V15/nodeJs/routesJs/frontend/js/renderers/blueprintPreview.js

@@ -0,0 +1,31 @@
+export function renderBlueprintPreview(schema) {
+    const previewContainer = document.getElementById("blueprint-preview-container");
+    if (!previewContainer) return;
+
+    previewContainer.classList.remove("hidden");
+    
+    const titleEl = document.getElementById("blueprint-title");
+    if (titleEl) titleEl.textContent = schema.tableName;
+    
+    const countEl = document.getElementById("blueprint-columns-count");
+    if (countEl) {
+        const count = schema.columns ? schema.columns.length : 0;
+        countEl.textContent = `${count} field${count === 1 ? '' : 's'} parsed`;
+    }
+
+    const columnsList = document.getElementById("blueprint-columns-list");
+    if (!columnsList) return;
+
+    columnsList.innerHTML = "";
+    
+    if (schema.columns && schema.columns.length > 0) {
+        schema.columns.forEach(col => {
+            const pill = document.createElement("span");
+            pill.className = "inline-flex items-center px-2.5 py-1 rounded bg-slate-800/60 text-slate-300 font-mono text-[10px] border border-slate-700/60 hover:bg-slate-700/40 hover:text-slate-100 transition-colors";
+            pill.textContent = col;
+            columnsList.appendChild(pill);
+        });
+    } else {
+        columnsList.innerHTML = `<span class="text-xs italic text-slate-500">No columns or properties extracted.</span>`;
+    }
+}

package/src/V15/nodeJs/routesJs/frontend/js/renderers/renderFolders.js

@@ -0,0 +1,43 @@
+export function renderFolders(foldersList) {
+    const container = document.getElementById("folders-list-container");
+    if (!container) return;
+
+    container.innerHTML = "";
+
+    if (foldersList && foldersList.length > 0) {
+        foldersList.forEach(loopFolder => {
+            const card = document.createElement("div");
+            card.className = "group relative flex items-center justify-between p-3 rounded-lg bg-slate-900/40 border border-slate-800/80 hover:border-violet-500/50 hover:bg-slate-800/40 transition-all duration-300";
+
+            const info = document.createElement("div");
+            info.className = "flex flex-col gap-0.5 truncate";
+
+            const name = document.createElement("span");
+            name.className = "font-mono font-medium text-xs text-slate-200 truncate";
+            name.textContent = loopFolder.folderName;
+            name.title = loopFolder.folderName;
+
+            const sub = document.createElement("span");
+            sub.className = "text-[10px] text-slate-500 font-mono";
+            sub.textContent = `router as ${loopFolder.variable || 'router'}`;
+
+            info.appendChild(name);
+            info.appendChild(sub);
+
+            const badge = document.createElement("span");
+            badge.className = "inline-flex items-center px-1.5 py-0.5 rounded text-[10px] font-medium bg-emerald-500/10 text-emerald-400 border border-emerald-500/20";
+            badge.textContent = "active";
+
+            card.appendChild(info);
+            card.appendChild(badge);
+            container.appendChild(card);
+        });
+    } else {
+        container.innerHTML = `
+            <div class="col-span-full flex flex-col items-center justify-center p-6 text-slate-500 bg-slate-900/20 rounded-xl border border-dashed border-slate-800">
+                <span class="text-2xl mb-1">📭</span>
+                <span class="text-xs italic">No existing API nodes found in routes.js</span>
+            </div>
+        `;
+    }
+}

package/src/V15/nodeJs/routesJs/frontend/js/renderers/renderSchemas.js

@@ -0,0 +1,55 @@
+export function renderSchemas(schemas, onSelect) {
+    const container = document.getElementById("schemas-list-container");
+    if (!container) return;
+
+    container.innerHTML = "";
+
+    if (schemas && schemas.length > 0) {
+        schemas.forEach(schema => {
+            const card = document.createElement("button");
+            card.type = "button";
+            card.className = "w-full text-left p-3 rounded-lg bg-slate-900/40 border border-slate-800/80 hover:border-violet-500/50 hover:bg-slate-800/40 transition-all duration-300 flex items-center justify-between group cursor-pointer focus:outline-none";
+            card.id = `schema-card-${schema.tableName}`;
+            
+            card.addEventListener("click", () => onSelect(schema));
+
+            const left = document.createElement("div");
+            left.className = "flex items-center gap-3 truncate";
+
+            const icon = document.createElement("div");
+            icon.className = "w-8 h-8 rounded-lg bg-violet-600/10 flex items-center justify-center text-violet-400 group-hover:bg-violet-600/20 transition-colors flex-shrink-0 border border-violet-500/10";
+            icon.textContent = "📊";
+
+            const details = document.createElement("div");
+            details.className = "flex flex-col gap-0.5 truncate";
+
+            const name = document.createElement("span");
+            name.className = "font-medium text-xs text-slate-200 group-hover:text-violet-300 transition-colors truncate";
+            name.textContent = schema.tableName;
+
+            const sub = document.createElement("span");
+            sub.className = "text-[10px] text-slate-500 font-mono truncate";
+            sub.textContent = schema.name;
+
+            details.appendChild(name);
+            details.appendChild(sub);
+            left.appendChild(icon);
+            left.appendChild(details);
+
+            const arrow = document.createElement("span");
+            arrow.className = "text-slate-600 group-hover:text-violet-400 transition-colors text-xs font-bold";
+            arrow.textContent = "→";
+
+            card.appendChild(left);
+            card.appendChild(arrow);
+            container.appendChild(card);
+        });
+    } else {
+        container.innerHTML = `
+            <div class="flex flex-col items-center justify-center p-6 text-slate-500 bg-slate-900/20 rounded-xl border border-dashed border-slate-800">
+                <span class="text-2xl mb-1">📂</span>
+                <span class="text-xs italic">No schema blueprints found in Config/Schemas</span>
+            </div>
+        `;
+    }
+}

package/src/V15/nodeJs/routesJs/frontend/js/renderers/selectSchema.js

@@ -0,0 +1,26 @@
+import { renderBlueprintPreview } from "./blueprintPreview.js";
+
+export function selectSchema(schema, schemasList) {
+    schemasList.forEach(s => {
+        const c = document.getElementById(`schema-card-${s.tableName}`);
+        if (c) {
+            c.classList.remove("border-violet-500", "bg-violet-950/20", "ring-1", "ring-violet-500/30");
+            c.classList.add("border-slate-800/80", "bg-slate-900/40");
+        }
+    });
+
+    const activeCard = document.getElementById(`schema-card-${schema.tableName}`);
+    if (activeCard) {
+        activeCard.classList.remove("border-slate-800/80", "bg-slate-900/40");
+        activeCard.classList.add("border-violet-500", "bg-violet-950/20", "ring-1", "ring-violet-500/30");
+    }
+
+    window.selectedTableName = schema.tableName;
+
+    const folderInput = document.getElementById("folder-name");
+    if (folderInput) {
+        folderInput.value = schema.tableName;
+    }
+
+    renderBlueprintPreview(schema);
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter/appendTerminalLog.js

@@ -0,0 +1,45 @@
+export function appendTerminalLog(text, type = "info") {
+    const terminalBody = document.getElementById("terminal-body");
+    if (!terminalBody) return;
+
+    const line = document.createElement("div");
+    line.className = "flex items-start gap-2 py-1 border-b border-slate-800/40 text-xs font-mono transition-opacity duration-300";
+
+    const timestamp = document.createElement("span");
+    timestamp.className = "text-slate-500 select-none flex-shrink-0";
+    const now = new Date();
+    timestamp.textContent = `[${now.toTimeString().split(' ')[0]}]`;
+
+    const icon = document.createElement("span");
+    icon.className = "flex-shrink-0";
+    
+    let colorClass = "text-slate-300";
+    if (type === "success") {
+        icon.textContent = "✔";
+        colorClass = "text-emerald-400 font-semibold";
+    } else if (type === "warning") {
+        icon.textContent = "⚠";
+        colorClass = "text-amber-400";
+    } else if (type === "error") {
+        icon.textContent = "✘";
+        colorClass = "text-rose-400 font-bold";
+    } else {
+        icon.textContent = "ℹ";
+        colorClass = "text-cyan-400";
+    }
+
+    const message = document.createElement("span");
+    message.className = colorClass;
+    message.textContent = text;
+
+    line.appendChild(timestamp);
+    line.appendChild(icon);
+    line.appendChild(message);
+    
+    terminalBody.appendChild(line);
+    
+    const terminalContainer = document.getElementById("terminal-container");
+    if (terminalContainer) {
+        terminalContainer.scrollTop = terminalContainer.scrollHeight;
+    }
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter/clearTerminal.js

@@ -0,0 +1,6 @@
+export function clearTerminal() {
+    const terminalBody = document.getElementById("terminal-body");
+    if (terminalBody) {
+        terminalBody.innerHTML = "";
+    }
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter/completeStatus.js

@@ -0,0 +1,7 @@
+import { showSummary } from "./showSummary.js";
+
+export function completeStatus(html) {
+    const statusDiv = document.getElementById("status");
+    if (statusDiv) statusDiv.classList.add("hidden");
+    showSummary(html);
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter/showError.js

@@ -0,0 +1,7 @@
+export function showError(text) {
+    const statusDiv = document.getElementById("status");
+    if (!statusDiv) return;
+    statusDiv.classList.remove("hidden", "border-violet-500/20", "bg-violet-500/5", "text-violet-300");
+    statusDiv.classList.add("border-rose-500/20", "bg-rose-500/5", "text-rose-400");
+    statusDiv.innerHTML = `<span class="flex items-center gap-2">⚠️ <span>${text}</span></span>`;
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter/showStatus.js

@@ -0,0 +1,7 @@
+export function showStatus(text) {
+    const statusDiv = document.getElementById("status");
+    if (!statusDiv) return;
+    statusDiv.classList.remove("hidden", "border-rose-500/20", "bg-rose-500/5", "text-rose-400");
+    statusDiv.classList.add("border-violet-500/20", "bg-violet-500/5", "text-violet-300");
+    statusDiv.innerHTML = `<span class="flex items-center gap-2">🔮 <span>${text}</span></span>`;
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter/showSummary.js

@@ -0,0 +1,7 @@
+export function showSummary(html) {
+    const summaryDiv = document.getElementById("summary");
+    if (!summaryDiv) return;
+    summaryDiv.classList.remove("hidden");
+    summaryDiv.innerHTML = html;
+    summaryDiv.scrollIntoView({ behavior: 'smooth' });
+}

package/src/V15/nodeJs/routesJs/frontend/js/uiPresenter.js

@@ -0,0 +1,6 @@
+export { showStatus } from "./uiPresenter/showStatus.js";
+export { showError } from "./uiPresenter/showError.js";
+export { showSummary } from "./uiPresenter/showSummary.js";
+export { completeStatus } from "./uiPresenter/completeStatus.js";
+export { clearTerminal } from "./uiPresenter/clearTerminal.js";
+export { appendTerminalLog } from "./uiPresenter/appendTerminalLog.js";

package/src/V15/nodeJs/routesJs/frontend/js/vscodeBridge.js

@@ -0,0 +1,5 @@
+const vscode = acquireVsCodeApi();
+
+export function sendAction(action, data = {}) {
+    vscode.postMessage({ action, ...data });
+}

package/src/V15/nodeJs/routesJs/v1/backend/core/htmlLoader.js

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import path from 'path';
+
+export function getHtmlWithScripts() {
+    const frontendDir = path.join(import.meta.dirname, "..", "..", "frontend");
+    let html = fs.readFileSync(path.join(frontendDir, "index.html"), "utf8");
+
+    const jsFiles = [
+        "vscodeBridge.js",
+        "forgeActions.js",
+        "uiPresenter.js",
+        "forgeController.js"
+    ];
+
+    const scriptTags = jsFiles.map(file => {
+        const content = fs.readFileSync(path.join(frontendDir, "js", file), "utf8");
+        return `<script>\n${content}\n</script>`;
+    }).join("\n");
+
+    if (html.includes("<!-- SCRIPTS -->")) {
+        html = html.replace("<!-- SCRIPTS -->", scriptTags);
+    } else {
+        html = html.replace("</body>", `${scriptTags}\n</body>`);
+    }
+
+    return html;
+}

package/src/V15/nodeJs/routesJs/v1/backend/core/messageRouter.js

@@ -0,0 +1,32 @@
+import forgeEndpointAction from "../forge/actions/forgeEndpoint.js";
+import { getSchemaFiles } from "../forge/schemaScanner.js";
+import getFolders from "../forge/routeScanner.js";
+
+export async function handleWebviewMessage({ message, panel, toPath, schemasPath,
+    port, inTargetPath }) {
+
+    switch (message.action) {
+        case "loadSchemas":
+            const schemas = getSchemaFiles(schemasPath);
+            const foldersAlreadyPresent = getFolders(toPath);
+
+            panel.webview.postMessage({
+                type: "showFolders",
+                foldersAlreadyPresent,
+                schemas
+            });
+            break;
+
+        case "addTableName":
+            await forgeEndpointAction({
+                panel,
+                tableName: message.tableName,
+                toPath,
+                schemasPath,
+                inFolderName: message.inFolderName,
+                inTargetPath,
+                inPort: port
+            });
+            break;
+    }
+}

package/src/V15/nodeJs/routesJs/v1/backend/core/workspaceHelper.js

@@ -0,0 +1,30 @@
+import * as vscode from 'vscode';
+import path from 'path';
+import fs from 'fs';
+
+export function getPortFromEnv(userRootFolder) {
+    if (!userRootFolder) return undefined;
+    const envPath = path.join(userRootFolder, ".env");
+    if (fs.existsSync(envPath)) {
+        const envContent = fs.readFileSync(envPath, "utf8");
+        const match = envContent.match(/^PORT\s*=\s*(.+)$/m);
+        if (match) {
+            return match[1].trim();
+        }
+    }
+    return undefined;
+}
+
+export function getWorkspaceContext(uri) {
+    const userRootFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    const schemasPath = userRootFolder ? path.join(userRootFolder, "Config", "Schemas") : undefined;
+    const folderPath = path.dirname(uri.fsPath);
+    const port = getPortFromEnv(userRootFolder);
+
+    return {
+        userRootFolder,
+        schemasPath,
+        folderPath,
+        port
+    };
+}

package/src/V15/nodeJs/routesJs/v1/backend/forge/actions/forgeEndpoint.js

@@ -0,0 +1,15 @@
+import addTableName from 'kschema-api-gen-endpointsjs';
+import { executeGenerationTask } from "../forgeEngine.js";
+
+const startFunc = async ({ panel, tableName, toPath, inFolderName }) => {
+    await executeGenerationTask({
+        panel,
+        actionLabel: "Add Table Name",
+        tableName,
+        toPath,
+        generateFunc: addTableName,
+        inFolderName
+    });
+};
+
+export default startFunc;

package/src/V15/nodeJs/routesJs/v1/backend/forge/forgeEngine.js

@@ -0,0 +1,83 @@
+import * as vscode from 'vscode';
+
+export async function executeGenerationTask({
+    panel,
+    actionLabel,
+    tableName,
+    toPath,
+    generateFunc,
+    inFolderName
+}) {
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+    const postLog = (text, type = "info") => {
+        panel.webview.postMessage({
+            type: "log",
+            text,
+            logType: type
+        });
+    };
+
+    try {
+        panel.webview.postMessage({ type: "startGeneration" });
+
+        postLog("🌌 Initializing the Endpoint Forge...", "info");
+        await sleep(300);
+
+        postLog(`📜 Reading the blueprint schema for: "${tableName}"`, "info");
+        await sleep(250);
+
+        postLog("🛡️ Validating routing pathways and target directories...", "info");
+        await sleep(200);
+
+        postLog("🔥 Igniting the endpoint generator template engine...", "warning");
+        await sleep(200);
+
+        postLog("⚙️ Generating HTTP handlers (GET, POST, PUT, DELETE)...", "info");
+        const funcToRun = await generateFunc();
+
+        await funcToRun({
+            showLog: true,
+            isAnnounce: true,
+            folderName: inFolderName || "",
+            toPath,
+            tableName
+        });
+        await sleep(350);
+
+        postLog("🧪 Integrating routes.js imports and configurations...", "info");
+        await sleep(300);
+
+        postLog("✨ Polishing generated code and formatting files...", "info");
+        await sleep(250);
+
+        postLog("💖 Endpoint successfully materialized!", "success");
+        await sleep(200);
+
+        panel.webview.postMessage({
+            type: "complete",
+            html: `
+                <div class="space-y-3">
+                    <div class="flex items-center gap-2 text-green-400 font-semibold text-lg">
+                        <span class="animate-bounce">✨</span>
+                        <span>Endpoint Forged Successfully!</span>
+                    </div>
+                    <div class="grid grid-cols-2 gap-2 text-sm bg-slate-900/60 p-3 rounded-lg border border-slate-700 font-mono">
+                        <div class="text-gray-400">Blueprint:</div>
+                        <div class="text-indigo-300 font-medium truncate">${tableName}</div>
+                        <div class="text-gray-400">Target Folder:</div>
+                        <div class="text-indigo-300 font-medium truncate">${inFolderName}</div>
+                        <div class="text-gray-400">Destination Path:</div>
+                        <div class="text-indigo-300 font-medium truncate" title="${toPath}">${toPath}</div>
+                    </div>
+                </div>
+            `
+        });
+    } catch (error) {
+        postLog(`🚨 Forge failed: ${error.message}`, "error");
+        panel.webview.postMessage({
+            type: "status",
+            text: `❌ Generation failed: ${error.message}`
+        });
+    }
+}

package/src/V15/nodeJs/routesJs/v1/backend/forge/routeScanner.js

@@ -0,0 +1,7 @@
+import getFolders from 'pattern-collector-routesjs-import-extract';
+
+const getFoldersFromImport = (toPath) => {
+    return getFolders({ filePath: toPath });
+};
+
+export default getFoldersFromImport;

package/src/V15/nodeJs/routesJs/v1/backend/forge/schemaScanner.js

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import path from 'path';
+
+export function getSchemaFiles(schemasPath) {
+    if (schemasPath === undefined || !fs.existsSync(schemasPath)) {
+        return [];
+    }
+
+    return fs.readdirSync(schemasPath, { withFileTypes: true })
+        .filter((item) => item.isFile() && item.name.endsWith(".json"))
+        .sort((first, second) => first.name.localeCompare(second.name))
+        .map((item) => {
+            const filePath = path.join(schemasPath, item.name);
+            const fallbackTableName = path.basename(item.name, ".json");
+
+            try {
+                const schema = JSON.parse(fs.readFileSync(filePath, "utf8"));
+                let columns = [];
+
+                if (schema.columns) {
+                    if (Array.isArray(schema.columns)) {
+                        columns = schema.columns.map(c => {
+                            if (typeof c === 'string') return c;
+                            return c.columnName || c.name || JSON.stringify(c);
+                        });
+                    } else if (typeof schema.columns === 'object') {
+                        columns = Object.keys(schema.columns);
+                    }
+                } else if (schema.properties) {
+                    columns = Object.keys(schema.properties);
+                } else if (schema.fields) {
+                    if (Array.isArray(schema.fields)) {
+                        columns = schema.fields.map(f => {
+                            if (typeof f === 'string') return f;
+                            return f.fieldName || f.name || JSON.stringify(f);
+                        });
+                    } else if (typeof schema.fields === 'object') {
+                        columns = Object.keys(schema.fields);
+                    }
+                } else {
+                    const keys = Object.keys(schema).filter(k => k !== 'tableName');
+                    if (keys.length > 0 && keys.length < 50) {
+                        columns = keys;
+                    }
+                }
+
+                return {
+                    name: item.name,
+                    tableName: schema.tableName || fallbackTableName,
+                    columns: columns.slice(0, 15) // limit size for UI preview
+                };
+            } catch {
+                return {
+                    name: item.name,
+                    tableName: fallbackTableName,
+                    columns: []
+                };
+            }
+        });
+}

package/src/V15/nodeJs/routesJs/v1/backend/readHtml.js

@@ -0,0 +1,31 @@
+import * as vscode from 'vscode';
+
+import { getHtmlWithScripts } from "./core/htmlLoader.js";
+import { handleWebviewMessage } from "./core/messageRouter.js";
+import { getWorkspaceContext } from "./core/workspaceHelper.js";
+
+const activateHtml = (context, uri) => {
+    const panel = vscode.window.createWebviewPanel(
+        "showHtml",
+        "Show Html",
+        vscode.ViewColumn.One,
+        { enableScripts: true }
+    );
+
+    panel.webview.html = getHtmlWithScripts();
+
+    panel.webview.onDidReceiveMessage(async (message) => {
+        const { userRootFolder, schemasPath, folderPath, port } = getWorkspaceContext(uri);
+
+        await handleWebviewMessage({
+            message,
+            panel,
+            toPath: folderPath,
+            schemasPath,
+            port,
+            inTargetPath: userRootFolder
+        });
+    });
+};
+
+export default activateHtml;