@timo9378/flow2code 0.1.2 → 0.1.4

package/dist/server.js

@@ -2175,6 +2175,826 @@ function buildSourceMap(code, ir, filePath) {
   };
 }
 
+// src/lib/compiler/decompiler.ts
+import {
+  Project as Project2,
+  SyntaxKind
+} from "ts-morph";
+function decompile(code, options = {}) {
+  const errors = [];
+  const { fileName = "input.ts", audit: enableAudit = true } = options;
+  try {
+    const project = new Project2({ useInMemoryFileSystem: true });
+    const sourceFile = project.createSourceFile(fileName, code);
+    const targetFn = findTargetFunction(sourceFile, options.functionName);
+    if (!targetFn) {
+      errors.push("No exported function found to decompile");
+      return { success: false, errors, confidence: 0 };
+    }
+    const ctx = createDecompileContext();
+    const trigger = createTriggerFromFunction(targetFn, sourceFile, ctx);
+    ctx.addNode(trigger);
+    const body = targetFn.fn.getBody();
+    if (body && body.getKind() === SyntaxKind.Block) {
+      walkBlock(body, trigger.id, ctx);
+    }
+    buildEdges(ctx);
+    const auditHints = enableAudit ? computeAuditHints(ctx) : [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ir = {
+      version: CURRENT_IR_VERSION,
+      meta: {
+        name: targetFn.name ?? fileName.replace(/\.(ts|tsx|js|jsx)$/, ""),
+        description: `Decompiled from ${fileName}`,
+        createdAt: now,
+        updatedAt: now
+      },
+      nodes: ctx.getNodes(),
+      edges: ctx.getEdges()
+    };
+    const nodeCount = ir.nodes.length;
+    const hasControlFlow = ir.nodes.some((n) => n.category === "logic" /* LOGIC */);
+    const confidence = Math.min(
+      0.95,
+      0.3 + nodeCount * 0.08 + (hasControlFlow ? 0.15 : 0)
+    );
+    return {
+      success: true,
+      ir,
+      errors: errors.length > 0 ? errors : void 0,
+      confidence,
+      audit: auditHints.length > 0 ? auditHints : void 0
+    };
+  } catch (err) {
+    return {
+      success: false,
+      errors: [err instanceof Error ? err.message : String(err)],
+      confidence: 0
+    };
+  }
+}
+function createDecompileContext() {
+  const ctx = {
+    nodes: /* @__PURE__ */ new Map(),
+    edgeList: [],
+    varDefs: /* @__PURE__ */ new Map(),
+    varUses: /* @__PURE__ */ new Map(),
+    seqPredecessors: /* @__PURE__ */ new Map(),
+    controlFlowChildren: /* @__PURE__ */ new Map(),
+    auditData: [],
+    counters: {},
+    nodeLines: /* @__PURE__ */ new Map(),
+    addNode(node, line) {
+      ctx.nodes.set(node.id, node);
+      if (line !== void 0) ctx.nodeLines.set(node.id, line);
+    },
+    getNodes() {
+      return Array.from(ctx.nodes.values());
+    },
+    getEdges() {
+      return ctx.edgeList;
+    },
+    nextId(prefix) {
+      ctx.counters[prefix] = (ctx.counters[prefix] ?? 0) + 1;
+      return `${prefix}_${ctx.counters[prefix]}`;
+    }
+  };
+  return ctx;
+}
+function findTargetFunction(sourceFile, targetName) {
+  const httpMethods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+  if (targetName) {
+    const fn = sourceFile.getFunction(targetName);
+    if (fn) {
+      const name = fn.getName();
+      const httpMethod = name && httpMethods.includes(name.toUpperCase()) ? name.toUpperCase() : void 0;
+      return { name: targetName, fn, httpMethod, isExported: fn.isExported() };
+    }
+  }
+  for (const fn of sourceFile.getFunctions()) {
+    if (!fn.isExported()) continue;
+    const name = fn.getName();
+    if (name && httpMethods.includes(name.toUpperCase())) {
+      return { name, fn, httpMethod: name.toUpperCase(), isExported: true };
+    }
+  }
+  for (const fn of sourceFile.getFunctions()) {
+    if (fn.isExported()) {
+      return { name: fn.getName(), fn, isExported: true };
+    }
+  }
+  const allFns = sourceFile.getFunctions();
+  if (allFns.length > 0) {
+    const fn = allFns[0];
+    return { name: fn.getName(), fn, isExported: fn.isExported() };
+  }
+  for (const stmt of sourceFile.getVariableStatements()) {
+    if (!stmt.isExported()) continue;
+    for (const decl of stmt.getDeclarations()) {
+      const init = decl.getInitializer();
+      if (init && init.getKind() === SyntaxKind.ArrowFunction) {
+        return {
+          name: decl.getName(),
+          fn: init,
+          isExported: true
+        };
+      }
+    }
+  }
+  return null;
+}
+function createTriggerFromFunction(target, sourceFile, ctx) {
+  const id = ctx.nextId("trigger");
+  if (target.httpMethod) {
+    const routePath = inferRoutePath(sourceFile);
+    const method = target.httpMethod;
+    const parseBody = method !== "GET";
+    return {
+      id,
+      nodeType: "http_webhook" /* HTTP_WEBHOOK */,
+      category: "trigger" /* TRIGGER */,
+      label: `${method} ${routePath}`,
+      params: { method, routePath, parseBody },
+      inputs: [],
+      outputs: [
+        { id: "request", label: "Request", dataType: "object" },
+        { id: "body", label: "Body", dataType: "object" },
+        { id: "query", label: "Query", dataType: "object" }
+      ]
+    };
+  }
+  return {
+    id,
+    nodeType: "manual" /* MANUAL */,
+    category: "trigger" /* TRIGGER */,
+    label: target.name ?? "Entry Point",
+    params: {
+      functionName: target.name ?? "handler",
+      args: target.fn.getParameters?.() ? target.fn.getParameters().map((p) => ({
+        name: p.getName(),
+        type: inferDataType(p.getType().getText())
+      })) : []
+    },
+    inputs: [],
+    outputs: [{ id: "output", label: "Output", dataType: "any" }]
+  };
+}
+function walkBlock(block, parentNodeId, ctx, controlFlowPort) {
+  const statements = block.getStatements();
+  let lastNodeId = parentNodeId;
+  for (const stmt of statements) {
+    const nodeId = processStatement(stmt, lastNodeId, ctx);
+    if (nodeId) {
+      if (lastNodeId !== parentNodeId || !controlFlowPort) {
+        ctx.seqPredecessors.set(nodeId, lastNodeId);
+      }
+      if (lastNodeId === parentNodeId && controlFlowPort) {
+        if (!ctx.controlFlowChildren.has(parentNodeId)) {
+          ctx.controlFlowChildren.set(parentNodeId, []);
+        }
+        ctx.controlFlowChildren.get(parentNodeId).push({
+          portId: controlFlowPort,
+          nodeId
+        });
+      }
+      lastNodeId = nodeId;
+    }
+  }
+}
+function processStatement(stmt, prevNodeId, ctx) {
+  const kind = stmt.getKind();
+  const line = stmt.getStartLineNumber();
+  switch (kind) {
+    case SyntaxKind.VariableStatement:
+      return processVariableStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.IfStatement:
+      return processIfStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.ForOfStatement:
+      return processForOfStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.ForInStatement:
+      return processForInStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.ForStatement:
+      return processForStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.TryStatement:
+      return processTryStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.ReturnStatement:
+      return processReturnStatement(stmt, prevNodeId, ctx, line);
+    case SyntaxKind.ExpressionStatement:
+      return processExpressionStatement(stmt, prevNodeId, ctx, line);
+    default:
+      return null;
+  }
+}
+function processVariableStatement(stmt, _prevNodeId, ctx, line) {
+  const declarations = stmt.getDeclarations();
+  if (declarations.length === 0) return null;
+  const decl = declarations[0];
+  return processVariableDeclaration(decl, ctx, line);
+}
+function processVariableDeclaration(decl, ctx, line) {
+  const varName = decl.getName();
+  const init = decl.getInitializer();
+  if (!init) return null;
+  const initText = init.getText();
+  if (isFetchCall(init)) {
+    const nodeId2 = ctx.nextId("fetch");
+    const node = parseFetchNode(nodeId2, initText, varName);
+    ctx.addNode(node, line);
+    ctx.varDefs.set(varName, { nodeId: nodeId2, portId: "data", varName });
+    return nodeId2;
+  }
+  if (hasAwaitExpression(init)) {
+    const nodeId2 = ctx.nextId("async_op");
+    const awaitedCode = extractAwaitedExpression(init);
+    ctx.addNode({
+      id: nodeId2,
+      nodeType: "custom_code" /* CUSTOM_CODE */,
+      category: "action" /* ACTION */,
+      label: inferLabel(awaitedCode, varName),
+      params: { code: awaitedCode, returnVariable: varName },
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "any" }]
+    }, line);
+    ctx.varDefs.set(varName, { nodeId: nodeId2, portId: "result", varName });
+    trackVariableUses(nodeId2, initText, ctx);
+    return nodeId2;
+  }
+  if (isSimpleDeclaration(init)) {
+    const nodeId2 = ctx.nextId("var");
+    const dataType = inferDataType(decl.getType().getText());
+    const isConst = decl.getVariableStatement()?.getDeclarationKind()?.toString() === "const";
+    ctx.addNode({
+      id: nodeId2,
+      nodeType: "declare" /* DECLARE */,
+      category: "variable" /* VARIABLE */,
+      label: varName,
+      params: {
+        name: varName,
+        dataType,
+        initialValue: initText,
+        isConst: isConst ?? true
+      },
+      inputs: [],
+      outputs: [{ id: "value", label: "Value", dataType }]
+    }, line);
+    ctx.varDefs.set(varName, { nodeId: nodeId2, portId: "value", varName });
+    trackVariableUses(nodeId2, initText, ctx);
+    return nodeId2;
+  }
+  const nodeId = ctx.nextId("transform");
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "transform" /* TRANSFORM */,
+    category: "variable" /* VARIABLE */,
+    label: varName,
+    params: { expression: initText },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+    outputs: [{ id: "output", label: "Output", dataType: "any" }]
+  }, line);
+  ctx.varDefs.set(varName, { nodeId, portId: "output", varName });
+  trackVariableUses(nodeId, initText, ctx);
+  return nodeId;
+}
+function processIfStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("if");
+  const condition = stmt.getExpression().getText();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "if_else" /* IF_ELSE */,
+    category: "logic" /* LOGIC */,
+    label: `if (${truncate(condition, 40)})`,
+    params: { condition },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+    outputs: [
+      { id: "true", label: "True", dataType: "any" },
+      { id: "false", label: "False", dataType: "any" }
+    ]
+  }, line);
+  trackVariableUses(nodeId, condition, ctx);
+  const thenBlock = stmt.getThenStatement();
+  if (thenBlock.getKind() === SyntaxKind.Block) {
+    walkBlock(thenBlock, nodeId, ctx, "true");
+  }
+  const elseStmt = stmt.getElseStatement();
+  if (elseStmt) {
+    if (elseStmt.getKind() === SyntaxKind.Block) {
+      walkBlock(elseStmt, nodeId, ctx, "false");
+    } else if (elseStmt.getKind() === SyntaxKind.IfStatement) {
+      const nestedId = processIfStatement(elseStmt, nodeId, ctx, elseStmt.getStartLineNumber());
+      if (!ctx.controlFlowChildren.has(nodeId)) {
+        ctx.controlFlowChildren.set(nodeId, []);
+      }
+      ctx.controlFlowChildren.get(nodeId).push({ portId: "false", nodeId: nestedId });
+    }
+  }
+  if (!elseStmt) {
+    ctx.auditData.push({
+      nodeId,
+      severity: "info",
+      message: "If statement has no else branch \u2014 consider handling the negative case",
+      line
+    });
+  }
+  return nodeId;
+}
+function processForOfStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("loop");
+  const initText = stmt.getInitializer().getText();
+  const itemVar = initText.replace(/^(const|let|var)\s+/, "");
+  const iterableExpr = stmt.getExpression().getText();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: `for (${itemVar} of ${truncate(iterableExpr, 30)})`,
+    params: {
+      iterableExpression: iterableExpr,
+      itemVariable: itemVar
+    },
+    inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+    outputs: [
+      { id: "item", label: "Item", dataType: "any" },
+      { id: "result", label: "Result", dataType: "array" }
+    ]
+  }, line);
+  trackVariableUses(nodeId, iterableExpr, ctx);
+  const body = stmt.getStatement();
+  if (body.getKind() === SyntaxKind.Block) {
+    walkBlock(body, nodeId, ctx, "item");
+  }
+  return nodeId;
+}
+function processForInStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("loop");
+  const initText = stmt.getInitializer().getText();
+  const itemVar = initText.replace(/^(const|let|var)\s+/, "");
+  const iterableExpr = stmt.getExpression().getText();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: `for (${itemVar} in ${truncate(iterableExpr, 30)})`,
+    params: {
+      iterableExpression: `Object.keys(${iterableExpr})`,
+      itemVariable: itemVar
+    },
+    inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+    outputs: [
+      { id: "item", label: "Item", dataType: "any" },
+      { id: "result", label: "Result", dataType: "array" }
+    ]
+  }, line);
+  trackVariableUses(nodeId, iterableExpr, ctx);
+  const body = stmt.getStatement();
+  if (body.getKind() === SyntaxKind.Block) {
+    walkBlock(body, nodeId, ctx, "item");
+  }
+  return nodeId;
+}
+function processForStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("loop");
+  const fullText = stmt.getText().split("{")[0].trim();
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "for_loop" /* FOR_LOOP */,
+    category: "logic" /* LOGIC */,
+    label: truncate(fullText, 50),
+    params: {
+      iterableExpression: fullText,
+      itemVariable: "i"
+    },
+    inputs: [{ id: "iterable", label: "Iterable", dataType: "array", required: true }],
+    outputs: [
+      { id: "item", label: "Item", dataType: "any" },
+      { id: "result", label: "Result", dataType: "array" }
+    ]
+  }, line);
+  const body = stmt.getStatement();
+  if (body.getKind() === SyntaxKind.Block) {
+    walkBlock(body, nodeId, ctx, "item");
+  }
+  return nodeId;
+}
+function processTryStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("trycatch");
+  const catchClause = stmt.getCatchClause();
+  const errorVar = catchClause?.getVariableDeclaration()?.getName() ?? "error";
+  ctx.addNode({
+    id: nodeId,
+    nodeType: "try_catch" /* TRY_CATCH */,
+    category: "logic" /* LOGIC */,
+    label: "Try / Catch",
+    params: { errorVariable: errorVar },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: true }],
+    outputs: [
+      { id: "success", label: "Success", dataType: "any" },
+      { id: "error", label: "Error", dataType: "object" }
+    ]
+  }, line);
+  const tryBlock = stmt.getTryBlock();
+  walkBlock(tryBlock, nodeId, ctx, "success");
+  if (catchClause) {
+    const catchBlock = catchClause.getBlock();
+    walkBlock(catchBlock, nodeId, ctx, "error");
+  }
+  return nodeId;
+}
+function processReturnStatement(stmt, _prevNodeId, ctx, line) {
+  const nodeId = ctx.nextId("response");
+  const returnExpr = stmt.getExpression();
+  const returnText = returnExpr?.getText() ?? "";
+  const isHttpResponse = returnText.includes("NextResponse") || returnText.includes("Response(") || returnText.includes(".json(") || returnText.includes("res.status") || returnText.includes("res.json");
+  if (isHttpResponse) {
+    const statusMatch = returnText.match(/status[:\s(]+(\d{3})/);
+    const bodyMatch = returnText.match(/\.json\((.+?)(?:,|\))/s);
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "return_response" /* RETURN_RESPONSE */,
+      category: "output" /* OUTPUT */,
+      label: `Response ${statusMatch?.[1] ?? "200"}`,
+      params: {
+        statusCode: statusMatch ? parseInt(statusMatch[1]) : 200,
+        bodyExpression: bodyMatch?.[1]?.trim() ?? returnText
+      },
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    }, line);
+  } else {
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "return_response" /* RETURN_RESPONSE */,
+      category: "output" /* OUTPUT */,
+      label: "Return",
+      params: {
+        statusCode: 200,
+        bodyExpression: returnText || "undefined"
+      },
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    }, line);
+  }
+  trackVariableUses(nodeId, returnText, ctx);
+  return nodeId;
+}
+function processExpressionStatement(stmt, _prevNodeId, ctx, line) {
+  const expr = stmt.getExpression();
+  const exprText = expr.getText();
+  if (isFetchCall(expr)) {
+    const nodeId = ctx.nextId("fetch");
+    const node = parseFetchNode(nodeId, exprText, void 0);
+    ctx.addNode(node, line);
+    return nodeId;
+  }
+  if (hasAwaitExpression(expr)) {
+    const nodeId = ctx.nextId("async_op");
+    const awaitedCode = extractAwaitedExpression(expr);
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "custom_code" /* CUSTOM_CODE */,
+      category: "action" /* ACTION */,
+      label: inferLabel(awaitedCode, void 0),
+      params: { code: awaitedCode },
+      inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+      outputs: [{ id: "result", label: "Result", dataType: "any" }]
+    }, line);
+    trackVariableUses(nodeId, exprText, ctx);
+    return nodeId;
+  }
+  const flowStateMatch = exprText.match(/flowState\['([^']+)'\]\s*=\s*(.+)/s);
+  if (flowStateMatch) {
+    return null;
+  }
+  if (exprText.includes("res.status") || exprText.includes("res.json")) {
+    const nodeId = ctx.nextId("response");
+    const statusMatch = exprText.match(/status\((\d+)\)/);
+    ctx.addNode({
+      id: nodeId,
+      nodeType: "return_response" /* RETURN_RESPONSE */,
+      category: "output" /* OUTPUT */,
+      label: `Response ${statusMatch?.[1] ?? "200"}`,
+      params: {
+        statusCode: statusMatch ? parseInt(statusMatch[1]) : 200,
+        bodyExpression: exprText
+      },
+      inputs: [{ id: "data", label: "Data", dataType: "any", required: true }],
+      outputs: []
+    }, line);
+    trackVariableUses(nodeId, exprText, ctx);
+    return nodeId;
+  }
+  return null;
+}
+function buildEdges(ctx) {
+  let edgeCounter = 0;
+  const addEdge = (source, sourcePort, target, targetPort) => {
+    const exists = ctx.edgeList.some(
+      (e) => e.sourceNodeId === source && e.targetNodeId === target && e.sourcePortId === sourcePort
+    );
+    if (exists) return;
+    ctx.edgeList.push({
+      id: `e${++edgeCounter}`,
+      sourceNodeId: source,
+      sourcePortId: sourcePort,
+      targetNodeId: target,
+      targetPortId: targetPort
+    });
+  };
+  const connectedTargets = /* @__PURE__ */ new Set();
+  for (const [nodeId, uses] of ctx.varUses) {
+    for (const use of uses) {
+      const def = ctx.varDefs.get(use.varName);
+      if (def && def.nodeId !== nodeId) {
+        addEdge(def.nodeId, def.portId, nodeId, use.portId);
+        connectedTargets.add(nodeId);
+      }
+    }
+  }
+  const resolveTargetPort = (targetNodeId, fallback) => {
+    const tgt = ctx.nodes.get(targetNodeId);
+    return tgt?.inputs?.[0]?.id ?? fallback;
+  };
+  for (const [parentId, children] of ctx.controlFlowChildren) {
+    for (const child of children) {
+      addEdge(parentId, child.portId, child.nodeId, resolveTargetPort(child.nodeId, "input"));
+      connectedTargets.add(child.nodeId);
+    }
+  }
+  for (const [nodeId, predId] of ctx.seqPredecessors) {
+    if (connectedTargets.has(nodeId)) continue;
+    const predNode = ctx.nodes.get(predId);
+    if (!predNode) continue;
+    const sourcePort = predNode.outputs[0]?.id ?? "output";
+    addEdge(predId, sourcePort, nodeId, resolveTargetPort(nodeId, "input"));
+  }
+}
+function computeAuditHints(ctx) {
+  const hints = [...ctx.auditData];
+  for (const [nodeId, node] of ctx.nodes) {
+    const line = ctx.nodeLines.get(nodeId);
+    if (node.nodeType === "custom_code" /* CUSTOM_CODE */ || node.nodeType === "fetch_api" /* FETCH_API */) {
+      const isInsideTryCatch = Array.from(ctx.controlFlowChildren.entries()).some(
+        ([parentId, children]) => {
+          const parent = ctx.nodes.get(parentId);
+          return parent?.nodeType === "try_catch" /* TRY_CATCH */ && children.some((c) => c.nodeId === nodeId);
+        }
+      );
+      let ancestorId = ctx.seqPredecessors.get(nodeId);
+      let foundTryCatch = isInsideTryCatch;
+      while (ancestorId && !foundTryCatch) {
+        const ancestor = ctx.nodes.get(ancestorId);
+        if (ancestor?.nodeType === "try_catch" /* TRY_CATCH */) foundTryCatch = true;
+        for (const [parentId, children] of ctx.controlFlowChildren) {
+          const parent = ctx.nodes.get(parentId);
+          if (parent?.nodeType === "try_catch" /* TRY_CATCH */ && children.some((c) => c.nodeId === nodeId)) {
+            foundTryCatch = true;
+          }
+        }
+        ancestorId = ctx.seqPredecessors.get(ancestorId);
+      }
+      if (!foundTryCatch) {
+        hints.push({
+          nodeId,
+          severity: "warning",
+          message: `Async operation "${node.label}" has no error handling (missing try/catch)`,
+          line
+        });
+      }
+    }
+    if (node.nodeType === "fetch_api" /* FETCH_API */) {
+      hints.push({
+        nodeId,
+        severity: "info",
+        message: "Consider checking response.ok or response.status after fetch",
+        line
+      });
+    }
+  }
+  return hints;
+}
+function isFetchCall(node) {
+  const text = node.getText();
+  return text.includes("fetch(") && (text.includes("await") || node.getKind() === SyntaxKind.AwaitExpression);
+}
+function hasAwaitExpression(node) {
+  if (node.getKind() === SyntaxKind.AwaitExpression) return true;
+  return node.getText().startsWith("await ");
+}
+function extractAwaitedExpression(node) {
+  const text = node.getText();
+  if (text.startsWith("await ")) return text.slice(6);
+  return text;
+}
+function isSimpleDeclaration(node) {
+  const text = node.getText();
+  return !text.includes("await") && !text.includes("fetch(") && (node.getKind() === SyntaxKind.StringLiteral || node.getKind() === SyntaxKind.NumericLiteral || node.getKind() === SyntaxKind.TrueKeyword || node.getKind() === SyntaxKind.FalseKeyword || node.getKind() === SyntaxKind.NullKeyword || node.getKind() === SyntaxKind.ArrayLiteralExpression || node.getKind() === SyntaxKind.ObjectLiteralExpression || node.getKind() === SyntaxKind.NewExpression);
+}
+function parseFetchNode(nodeId, text, varName) {
+  const urlMatch = text.match(/fetch\(([^,)]+)/);
+  let url = urlMatch?.[1]?.trim() ?? '""';
+  url = url.replace(/^[`"']|[`"']$/g, "");
+  const methodMatch = text.match(/method:\s*["'](\w+)["']/);
+  const method = methodMatch?.[1]?.toUpperCase() ?? "GET";
+  const headerMatch = text.match(/headers:\s*(\{[^}]+\})/);
+  let headers;
+  if (headerMatch) {
+    headers = {};
+    const headerPairs = headerMatch[1].matchAll(/"([^"]+)":\s*"([^"]+)"/g);
+    for (const pair of headerPairs) {
+      headers[pair[1]] = pair[2];
+    }
+  }
+  return {
+    id: nodeId,
+    nodeType: "fetch_api" /* FETCH_API */,
+    category: "action" /* ACTION */,
+    label: `Fetch ${truncate(url, 30) || varName || "API"}`,
+    params: {
+      url,
+      method,
+      headers,
+      parseJson: text.includes(".json()")
+    },
+    inputs: [{ id: "input", label: "Input", dataType: "any", required: false }],
+    outputs: [
+      { id: "response", label: "Response", dataType: "object" },
+      { id: "data", label: "Data", dataType: "any" }
+    ]
+  };
+}
+function inferRoutePath(sourceFile) {
+  const filePath = sourceFile.getFilePath();
+  const appRouterMatch = filePath.match(/\/app\/api\/(.+?)\/route\.(ts|js)/);
+  if (appRouterMatch) return `/api/${appRouterMatch[1]}`;
+  const pagesMatch = filePath.match(/\/pages\/api\/(.+?)\.(ts|js)/);
+  if (pagesMatch) return `/api/${pagesMatch[1]}`;
+  const fullText = sourceFile.getFullText();
+  const routeMatch = fullText.match(/\/api\/\S+/);
+  if (routeMatch) return routeMatch[0];
+  return "/api/handler";
+}
+function inferDataType(tsType) {
+  if (tsType.includes("string")) return "string";
+  if (tsType.includes("number")) return "number";
+  if (tsType.includes("boolean")) return "boolean";
+  if (tsType.includes("[]") || tsType.includes("Array")) return "array";
+  if (tsType.includes("{") || tsType.includes("Record") || tsType.includes("object")) return "object";
+  return "any";
+}
+function inferLabel(code, varName) {
+  const callMatch = code.match(/^(\w+(?:\.\w+)*)\(/);
+  if (callMatch) return callMatch[1];
+  if (varName) return varName;
+  return truncate(code, 30);
+}
+function trackVariableUses(nodeId, expression, ctx) {
+  const identifiers = expression.match(/\b([a-zA-Z_]\w*)\b/g);
+  if (!identifiers) return;
+  const uses = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ident of identifiers) {
+    if (SKIP_IDENTIFIERS.has(ident)) continue;
+    if (seen.has(ident)) continue;
+    seen.add(ident);
+    if (ctx.varDefs.has(ident)) {
+      const targetNode = ctx.nodes.get(nodeId);
+      const portId = targetNode?.inputs?.[0]?.id ?? "input";
+      uses.push({ nodeId, portId, varName: ident });
+    }
+  }
+  if (uses.length > 0) {
+    const existing = ctx.varUses.get(nodeId) ?? [];
+    ctx.varUses.set(nodeId, [...existing, ...uses]);
+  }
+}
+var SKIP_IDENTIFIERS = /* @__PURE__ */ new Set([
+  // JS keywords
+  "const",
+  "let",
+  "var",
+  "function",
+  "return",
+  "if",
+  "else",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "case",
+  "break",
+  "continue",
+  "throw",
+  "try",
+  "catch",
+  "finally",
+  "new",
+  "delete",
+  "typeof",
+  "void",
+  "in",
+  "of",
+  "instanceof",
+  "this",
+  "super",
+  "class",
+  "extends",
+  "import",
+  "export",
+  "default",
+  "from",
+  "as",
+  "async",
+  "await",
+  "yield",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  // Common globals
+  "console",
+  "JSON",
+  "Math",
+  "Date",
+  "Error",
+  "Promise",
+  "Array",
+  "Object",
+  "String",
+  "Number",
+  "Boolean",
+  "Map",
+  "Set",
+  "RegExp",
+  "Symbol",
+  "Buffer",
+  "process",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval",
+  "fetch",
+  "Response",
+  "Request",
+  "Headers",
+  "URL",
+  "URLSearchParams",
+  "NextResponse",
+  "NextRequest",
+  // Common methods
+  "log",
+  "error",
+  "warn",
+  "stringify",
+  "parse",
+  "json",
+  "text",
+  "toString",
+  "map",
+  "filter",
+  "reduce",
+  "forEach",
+  "find",
+  "some",
+  "every",
+  "includes",
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "slice",
+  "splice",
+  "concat",
+  "join",
+  "keys",
+  "values",
+  "entries",
+  "assign",
+  "freeze",
+  "status",
+  "ok",
+  "headers",
+  "body",
+  "method",
+  "url",
+  "length",
+  "trim",
+  "split",
+  "replace",
+  "match",
+  "test",
+  "exec",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "then",
+  "catch",
+  "finally"
+]);
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
 // src/lib/ir/security.ts
 var SECURITY_PATTERNS = [
   // ── Critical: Remote Code Execution / System Access ──
@@ -2208,7 +3028,7 @@ var SECURITY_PATTERNS = [
   { pattern: /\bwhile\s*\(\s*true\s*\)/, desc: "while(true) \u2014 possible infinite loop", severity: "info" },
   { pattern: /\bfor\s*\(\s*;\s*;\s*\)/, desc: "for(;;) \u2014 possible infinite loop", severity: "info" }
 ];
-function truncate(str, maxLen) {
+function truncate2(str, maxLen) {
   return str.length > maxLen ? str.slice(0, maxLen) + "\u2026" : str;
 }
 function scanCode(nodeId, nodeLabel, code) {
@@ -2222,7 +3042,7 @@ function scanCode(nodeId, nodeLabel, code) {
         nodeId,
         nodeLabel,
         pattern: desc,
-        match: truncate(match[0], 80)
+        match: truncate2(match[0], 80)
       });
     }
   }
@@ -2822,6 +3642,50 @@ function handleImportOpenAPI(body) {
     };
   }
 }
+function handleDecompile(body) {
+  try {
+    const { code, fileName, functionName } = body;
+    if (!code || typeof code !== "string") {
+      return { status: 400, body: { success: false, error: "Missing 'code' string in request body" } };
+    }
+    if (code.trim().length === 0) {
+      return { status: 400, body: { success: false, error: "Code is empty" } };
+    }
+    const result = decompile(code, {
+      fileName: fileName ?? "input.ts",
+      functionName,
+      audit: true
+    });
+    if (!result.success) {
+      return {
+        status: 422,
+        body: {
+          success: false,
+          errors: result.errors ?? ["Decompile failed"],
+          confidence: result.confidence
+        }
+      };
+    }
+    return {
+      status: 200,
+      body: {
+        success: true,
+        ir: result.ir,
+        confidence: result.confidence,
+        errors: result.errors ?? [],
+        audit: result.audit ?? []
+      }
+    };
+  } catch (err) {
+    return {
+      status: 500,
+      body: {
+        success: false,
+        error: `Decompile error: ${err instanceof Error ? err.message : String(err)}`
+      }
+    };
+  }
+}
 
 // src/server/index.ts
 var __filename = fileURLToPath(import.meta.url);
@@ -2986,6 +3850,11 @@ async function handleRequest(req, res, staticDir, projectRoot) {
       sendJson(res, result.status, result.body);
       return;
     }
+    if (pathname === "/api/decompile") {
+      const result = handleDecompile(body);
+      sendJson(res, result.status, result.body);
+      return;
+    }
     sendJson(res, 404, { error: `Unknown API route: ${pathname}` });
     return;
   }
@@ -3013,6 +3882,7 @@ function startServer(options = {}) {
       res.end("Internal Server Error");
     });
   });
+  const hasUI = existsSync2(join2(staticDir, "index.html"));
   server.listen(port, host, () => {
     const url = `http://localhost:${port}`;
     if (options.onReady) {
@@ -3023,14 +3893,22 @@ function startServer(options = {}) {
       console.log(`  \u251C\u2500 Local:   ${url}`);
       console.log(`  \u251C\u2500 API:     ${url}/api/compile`);
       console.log(`  \u251C\u2500 Static:  ${staticDir}`);
-      console.log(`  \u2514\u2500 Project: ${projectRoot}
-`);
+      console.log(`  \u2514\u2500 Project: ${projectRoot}`);
+      if (!hasUI) {
+        console.log();
+        console.log(`  \u26A0\uFE0F  UI files not found (out/index.html missing).`);
+        console.log(`     The API endpoints still work, but the visual editor won't load.`);
+        console.log(`     To fix: run "pnpm build:ui" in the flow2code source directory,`);
+        console.log(`     or reinstall from npm: npm i @timo9378/flow2code@latest`);
+      }
+      console.log();
     }
   });
   return server;
 }
 export {
   handleCompile,
+  handleDecompile,
   handleGenerate,
   handleImportOpenAPI,
   startServer