@aprovan/patchwork-vscode 0.1.0

package/dist/extension.js

@@ -0,0 +1,1405 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/extension.ts
+var extension_exports = {};
+__export(extension_exports, {
+  activate: () => activate,
+  deactivate: () => deactivate
+});
+module.exports = __toCommonJS(extension_exports);
+var path2 = __toESM(require("path"));
+var vscode4 = __toESM(require("vscode"));
+var import_patchwork_compiler = require("@aprovan/patchwork-compiler");
+
+// src/providers/PatchworkFileSystemProvider.ts
+var vscode = __toESM(require("vscode"));
+var PatchworkFileSystemProvider = class {
+  onDidChangeFileEmitter = new vscode.EventEmitter();
+  onDidChangeFile = this.onDidChangeFileEmitter.event;
+  projects = /* @__PURE__ */ new Map();
+  setProject(id, project) {
+    this.projects.set(id, project);
+    this.onDidChangeFileEmitter.fire([]);
+  }
+  clearProjects() {
+    this.projects.clear();
+    this.onDidChangeFileEmitter.fire([]);
+  }
+  readFile(uri) {
+    const { projectId, path: path3 } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    const file = project.files.get(path3);
+    if (!file) throw vscode.FileSystemError.FileNotFound(uri);
+    return this.encodeFileContent(file);
+  }
+  writeFile(uri, content, options) {
+    const { projectId, path: path3 } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    const exists = project.files.has(path3);
+    if (!exists && !options.create) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+    if (exists && !options.overwrite) {
+      throw vscode.FileSystemError.FileExists(uri);
+    }
+    const file = this.decodeFileContent(path3, content);
+    project.files.set(path3, file);
+    this.onDidChangeFileEmitter.fire([
+      {
+        type: exists ? vscode.FileChangeType.Changed : vscode.FileChangeType.Created,
+        uri
+      }
+    ]);
+  }
+  stat(uri) {
+    const { projectId, path: path3 } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    if (!path3) {
+      return {
+        type: vscode.FileType.Directory,
+        ctime: 0,
+        mtime: 0,
+        size: 0
+      };
+    }
+    const file = project.files.get(path3);
+    if (file) {
+      return {
+        type: vscode.FileType.File,
+        ctime: 0,
+        mtime: 0,
+        size: this.encodeFileContent(file).byteLength
+      };
+    }
+    if (this.hasDirectory(project, path3)) {
+      return {
+        type: vscode.FileType.Directory,
+        ctime: 0,
+        mtime: 0,
+        size: 0
+      };
+    }
+    throw vscode.FileSystemError.FileNotFound(uri);
+  }
+  readDirectory(uri) {
+    const { projectId, path: path3 } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    return this.listDirectoryEntries(project, path3);
+  }
+  createDirectory() {
+    throw vscode.FileSystemError.NoPermissions(
+      "Patchwork file system is read/write via file edits only."
+    );
+  }
+  delete() {
+    throw vscode.FileSystemError.NoPermissions(
+      "Patchwork file deletion is not implemented yet."
+    );
+  }
+  rename() {
+    throw vscode.FileSystemError.NoPermissions(
+      "Patchwork file rename is not implemented yet."
+    );
+  }
+  watch() {
+    return new vscode.Disposable(() => void 0);
+  }
+  parseUri(uri) {
+    if (uri.scheme !== "patchwork") {
+      throw vscode.FileSystemError.Unavailable(
+        "Unsupported URI scheme for Patchwork provider."
+      );
+    }
+    const projectId = uri.authority;
+    if (!projectId) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+    const path3 = uri.path.replace(/^\/+/, "");
+    return { projectId, path: path3 };
+  }
+  getProject(projectId) {
+    const project = this.projects.get(projectId);
+    if (!project) {
+      throw vscode.FileSystemError.FileNotFound(
+        vscode.Uri.parse(`patchwork://${projectId}`)
+      );
+    }
+    return project;
+  }
+  encodeFileContent(file) {
+    if (file.encoding === "base64") {
+      return Buffer.from(file.content, "base64");
+    }
+    return Buffer.from(file.content, "utf8");
+  }
+  decodeFileContent(path3, content) {
+    const hasNull = content.some((byte) => byte === 0);
+    if (hasNull) {
+      return {
+        path: path3,
+        content: Buffer.from(content).toString("base64"),
+        encoding: "base64"
+      };
+    }
+    return {
+      path: path3,
+      content: Buffer.from(content).toString("utf8"),
+      encoding: "utf8"
+    };
+  }
+  hasDirectory(project, path3) {
+    const prefix = path3.endsWith("/") ? path3 : `${path3}/`;
+    for (const filePath of project.files.keys()) {
+      if (filePath.startsWith(prefix)) return true;
+    }
+    return false;
+  }
+  listDirectoryEntries(project, path3) {
+    const prefix = path3 ? `${path3.replace(/\/+$/, "")}/` : "";
+    const entries = /* @__PURE__ */ new Map();
+    for (const filePath of project.files.keys()) {
+      if (!filePath.startsWith(prefix)) continue;
+      const remainder = filePath.slice(prefix.length);
+      if (!remainder) continue;
+      const [segment, ...rest] = remainder.split("/");
+      if (!segment) continue;
+      if (rest.length === 0) {
+        entries.set(segment, vscode.FileType.File);
+      } else if (!entries.has(segment)) {
+        entries.set(segment, vscode.FileType.Directory);
+      }
+    }
+    return Array.from(entries.entries()).sort(
+      (a, b) => a[0].localeCompare(b[0])
+    );
+  }
+};
+
+// src/providers/PatchworkTreeProvider.ts
+var vscode2 = __toESM(require("vscode"));
+var PatchworkTreeItem = class _PatchworkTreeItem extends vscode2.TreeItem {
+  kind;
+  projectId;
+  path;
+  children;
+  constructor(node, collapsibleState) {
+    super(node.label, collapsibleState);
+    this.kind = node.kind;
+    this.projectId = node.projectId;
+    this.path = node.path;
+    this.children = node.children?.map(
+      (child) => new _PatchworkTreeItem(
+        child,
+        child.children && child.children.length > 0 ? vscode2.TreeItemCollapsibleState.Collapsed : vscode2.TreeItemCollapsibleState.None
+      )
+    );
+    if (this.kind === "folder" || this.kind === "project") {
+      this.iconPath = vscode2.ThemeIcon.Folder;
+    } else if (this.kind === "file") {
+      this.iconPath = vscode2.ThemeIcon.File;
+      if (this.projectId && this.path) {
+        this.command = {
+          command: "patchwork.openFile",
+          title: "Open Patchwork File",
+          arguments: [this.projectId, this.path]
+        };
+        this.tooltip = this.path;
+      }
+    }
+  }
+};
+var PatchworkTreeProvider = class {
+  onDidChangeTreeDataEmitter = new vscode2.EventEmitter();
+  onDidChangeTreeData = this.onDidChangeTreeDataEmitter.event;
+  projects = /* @__PURE__ */ new Map();
+  setProject(id, project) {
+    this.projects.set(id, project);
+    this.onDidChangeTreeDataEmitter.fire(void 0);
+  }
+  clearProjects() {
+    this.projects.clear();
+    this.onDidChangeTreeDataEmitter.fire(void 0);
+  }
+  getTreeItem(element) {
+    return element;
+  }
+  getChildren(element) {
+    if (!element) {
+      if (this.projects.size === 0) {
+        return Promise.resolve([
+          new PatchworkTreeItem(
+            { label: "No Patchwork projects", kind: "empty" },
+            vscode2.TreeItemCollapsibleState.None
+          )
+        ]);
+      }
+      const projectItems = Array.from(this.projects.values()).sort((a, b) => a.id.localeCompare(b.id)).map(
+        (project) => new PatchworkTreeItem(
+          {
+            label: project.id,
+            kind: "project",
+            projectId: project.id,
+            children: this.buildProjectNodes(project)
+          },
+          vscode2.TreeItemCollapsibleState.Collapsed
+        )
+      );
+      return Promise.resolve(projectItems);
+    }
+    if (element.children) {
+      return Promise.resolve(element.children);
+    }
+    return Promise.resolve([]);
+  }
+  buildProjectNodes(project) {
+    const root = {
+      label: project.id,
+      kind: "project",
+      projectId: project.id,
+      path: "",
+      children: /* @__PURE__ */ new Map()
+    };
+    for (const [path3] of project.files) {
+      const parts = path3.split("/").filter(Boolean);
+      let current = root;
+      let currentPath = "";
+      for (let index = 0; index < parts.length; index += 1) {
+        const part = parts[index];
+        const isFile = index === parts.length - 1;
+        currentPath = currentPath ? `${currentPath}/${part}` : part;
+        if (!current.children.has(part)) {
+          current.children.set(part, {
+            label: part,
+            kind: isFile ? "file" : "folder",
+            projectId: project.id,
+            path: currentPath,
+            children: /* @__PURE__ */ new Map()
+          });
+        }
+        const next = current.children.get(part);
+        if (next) current = next;
+      }
+    }
+    const collectChildren = (nodeMap) => {
+      const nodes = Array.from(nodeMap.values());
+      return nodes.sort((a, b) => {
+        if (a.kind !== b.kind) return a.kind === "folder" ? -1 : 1;
+        return a.label.localeCompare(b.label);
+      }).map((node) => ({
+        label: node.label,
+        kind: node.kind,
+        projectId: node.projectId,
+        path: node.path,
+        children: node.kind === "file" ? void 0 : collectChildren(node.children)
+      }));
+    };
+    return collectChildren(root.children);
+  }
+};
+
+// src/providers/PreviewPanelProvider.ts
+var path = __toESM(require("path"));
+var vscode3 = __toESM(require("vscode"));
+var PreviewPanelProvider = class {
+  constructor(context, handlers = {}) {
+    this.context = context;
+    this.handlers = handlers;
+  }
+  panel;
+  activeDocument;
+  showPreview(document) {
+    if (!this.isPreviewableDocument(document)) {
+      vscode3.window.showInformationMessage(
+        "Patchwork: preview supports .tsx/.jsx files only."
+      );
+      return;
+    }
+    this.activeDocument = document;
+    if (this.panel) {
+      this.panel.reveal(vscode3.ViewColumn.Beside);
+      this.postActiveDocument();
+      return;
+    }
+    this.panel = vscode3.window.createWebviewPanel(
+      "patchworkPreview",
+      "Patchwork Preview",
+      vscode3.ViewColumn.Beside,
+      {
+        enableScripts: true,
+        retainContextWhenHidden: true
+      }
+    );
+    this.panel.webview.html = this.getWebviewHtml(this.panel.webview);
+    this.panel.webview.onDidReceiveMessage(
+      (message) => {
+        if (message?.type === "ready") {
+          this.postActiveDocument();
+          this.handlers.onWebviewReady?.();
+          return;
+        }
+        if (message?.type === "compileError") {
+          this.handlers.onCompileError?.(message.payload, this.activeDocument);
+          return;
+        }
+        if (message?.type === "compileSuccess") {
+          this.handlers.onCompileSuccess?.(this.activeDocument);
+          return;
+        }
+        if (message?.type === "editRequest") {
+          this.handlers.onEditRequest?.(message.payload, this.activeDocument);
+          return;
+        }
+        if (message?.type === "serviceCall") {
+          this.handlers.onServiceCall?.(message.payload);
+        }
+      },
+      void 0,
+      this.context.subscriptions
+    );
+    this.panel.onDidDispose(() => {
+      this.panel = void 0;
+      this.activeDocument = void 0;
+    });
+  }
+  updateDocument(document) {
+    if (!this.panel) return;
+    if (!this.isPreviewableDocument(document)) return;
+    this.activeDocument = document;
+    this.postActiveDocument();
+  }
+  postActiveDocument() {
+    if (!this.panel || !this.activeDocument) return;
+    const payload = {
+      uri: this.activeDocument.uri.toString(),
+      languageId: this.activeDocument.languageId,
+      text: this.activeDocument.getText()
+    };
+    this.panel.webview.postMessage({ type: "updateFile", payload });
+  }
+  postMessage(message) {
+    if (!this.panel) return;
+    this.panel.webview.postMessage(message);
+  }
+  getWebviewHtml(webview) {
+    const nonce = this.getNonce();
+    const csp = `default-src 'none'; img-src ${webview.cspSource} https:; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-${nonce}' https:; connect-src https:;`;
+    const compilerUri = webview.asWebviewUri(
+      vscode3.Uri.joinPath(
+        this.context.extensionUri,
+        "node_modules",
+        "@aprovan",
+        "patchwork-compiler",
+        "dist",
+        "index.js"
+      )
+    );
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta http-equiv="Content-Security-Policy" content="${csp}" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Patchwork Preview</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      margin: 0;
+      padding: 16px;
+      color: var(--vscode-editor-foreground);
+      background: var(--vscode-editor-background);
+    }
+    .header {
+      font-size: 12px;
+      letter-spacing: 0.08em;
+      text-transform: uppercase;
+      opacity: 0.7;
+      margin-bottom: 12px;
+    }
+    pre {
+      white-space: pre-wrap;
+      word-break: break-word;
+      border-radius: 8px;
+      padding: 12px;
+      background: var(--vscode-editorWidget-background);
+    }
+    #preview {
+      min-height: 120px;
+      border-radius: 8px;
+      padding: 12px;
+      background: var(--vscode-editorWidget-background);
+      margin-bottom: 12px;
+    }
+    .error {
+      background: var(--vscode-inputValidation-errorBackground);
+      color: var(--vscode-inputValidation-errorForeground);
+      border: 1px solid var(--vscode-inputValidation-errorBorder);
+      border-radius: 6px;
+      padding: 8px 10px;
+      margin-bottom: 12px;
+      font-size: 12px;
+      white-space: pre-wrap;
+    }
+    .edit-bar {
+      display: flex;
+      gap: 8px;
+      align-items: center;
+      margin-bottom: 12px;
+    }
+    .edit-input {
+      flex: 1;
+      background: var(--vscode-input-background);
+      color: var(--vscode-input-foreground);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 6px;
+      padding: 6px 8px;
+    }
+    .edit-submit {
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border: none;
+      border-radius: 6px;
+      padding: 6px 10px;
+      cursor: pointer;
+    }
+    .edit-submit:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+    .edit-secondary {
+      background: var(--vscode-button-secondaryBackground);
+      color: var(--vscode-button-secondaryForeground);
+      border: none;
+      border-radius: 6px;
+      padding: 6px 10px;
+      cursor: pointer;
+    }
+    .edit-secondary:hover {
+      background: var(--vscode-button-secondaryHoverBackground);
+    }
+    .edit-status {
+      font-size: 11px;
+      opacity: 0.7;
+    }
+    .history-panel {
+      border-radius: 8px;
+      border: 1px solid var(--vscode-panel-border);
+      background: var(--vscode-sideBar-background);
+      margin-bottom: 12px;
+    }
+    .history-header {
+      padding: 8px 10px;
+      font-size: 12px;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      opacity: 0.7;
+      border-bottom: 1px solid var(--vscode-panel-border);
+    }
+    .history-list {
+      max-height: 200px;
+      overflow-y: auto;
+      padding: 8px 10px;
+      display: grid;
+      gap: 10px;
+    }
+    .history-item {
+      background: var(--vscode-editorWidget-background);
+      border-radius: 6px;
+      padding: 8px 10px;
+      border: 1px solid var(--vscode-panel-border);
+    }
+    .history-prompt {
+      font-size: 12px;
+      font-weight: 600;
+      margin-bottom: 6px;
+    }
+    .history-summary {
+      font-size: 12px;
+      opacity: 0.8;
+    }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <span>Patchwork Preview</span>
+    <span id="services-label" class="services-label"></span>
+  </div>
+  <div id="error" class="error" hidden></div>
+  <form id="edit-form" class="edit-bar">
+    <input id="edit-input" class="edit-input" placeholder="Ask Patchwork to edit" />
+    <button id="edit-submit" class="edit-submit" type="submit">Edit</button>
+    <button id="history-toggle" class="edit-secondary" type="button">History</button>
+    <span id="edit-status" class="edit-status"></span>
+  </form>
+  <section id="history-panel" class="history-panel" hidden>
+    <div class="history-header">Edit History</div>
+    <div id="history-list" class="history-list"></div>
+  </section>
+  <div id="preview"></div>
+  <pre id="payload">Waiting for file...</pre>
+  <script type="module" nonce="${nonce}">
+    const vscode = acquireVsCodeApi();
+    const output = document.getElementById('payload');
+    const previewRoot = document.getElementById('preview');
+    const errorBox = document.getElementById('error');
+    const compilerUrl = "${compilerUri}";
+    const fallbackCompilerUrl = "https://esm.sh/@aprovan/patchwork-compiler@0.1.0";
+    const imagePackage = "@aprovan/patchwork-image-shadcn";
+    const proxyBase = "https://patchwork.local/api/proxy";
+    let compiler = null;
+    let mounted = null;
+    let editBuffer = '';
+    const pendingServices = new Map();
+    let serviceNamespaces = [];
+    const servicesLabel = document.getElementById('services-label');
+
+    async function loadCompiler() {
+      try {
+        return await import(compilerUrl);
+      } catch (error) {
+        console.warn('[patchwork-vscode] Failed to load local compiler:', error);
+        return import(fallbackCompilerUrl);
+      }
+    }
+
+    async function ensureCompiler() {
+      if (compiler) return compiler;
+      const mod = await loadCompiler();
+        compiler = await mod.createCompiler({
+        image: imagePackage,
+          proxyUrl: proxyBase,
+      });
+      return compiler;
+    }
+
+    function setError(message) {
+      if (!message) {
+        errorBox.hidden = true;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        errorBox.textContent = '';
+      .services-label {
+        font-size: 10px;
+        text-transform: none;
+        letter-spacing: 0.02em;
+        padding: 4px 6px;
+        border-radius: 999px;
+        background: var(--vscode-badge-background);
+        color: var(--vscode-badge-foreground);
+        opacity: 0.9;
+      }
+        return;
+      }
+      errorBox.hidden = false;
+      errorBox.textContent = message;
+    }
+
+    async function compileAndMount(text) {
+      if (!previewRoot) return;
+      try {
+        setError('');
+        const activeCompiler = await ensureCompiler();
+        if (mounted) {
+          activeCompiler.unmount(mounted);
+          mounted = null;
+        }
+        const manifest = {
+          name: 'preview',
+          version: '0.0.0',
+          platform: 'browser',
+          image: imagePackage,
+        };
+        const widget = await activeCompiler.compile(text, manifest, {
+          typescript: true,
+        });
+        mounted = await activeCompiler.mount(widget, {
+          target: previewRoot,
+          mode: 'embedded',
+        });
+        vscode.postMessage({ type: 'compileSuccess' });
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error('Compile failed');
+        setError(err.message);
+        vscode.postMessage({
+          type: 'compileError',
+          payload: { message: err.message, line: 1, column: 1 },
+        });
+      }
+    }
+
+    const originalFetch = window.fetch.bind(window);
+    window.fetch = async (input, init) => {
+      const url = typeof input === 'string' ? input : input.url;
+      if (url && url.startsWith(proxyBase)) {
+        const parsed = new URL(url);
+        const parts = parsed.pathname.split('/').filter(Boolean);
+        const namespace = parts[2];
+        const procedure = parts.slice(3).join('/');
+        const body = init?.body ? JSON.parse(init.body) : {};
+        const args = body.args || {};
+        try {
+          const result = await callService(namespace, procedure, args);
+          if (result && result.error) {
+            return new Response(JSON.stringify({ error: result.error }), {
+              status: 500,
+              headers: { 'Content-Type': 'application/json' },
+            });
+          }
+          return new Response(JSON.stringify(result?.result ?? result), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error.message : 'Service call failed';
+          return new Response(JSON.stringify({ error: err }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+          });
+        }
+      }
+      return originalFetch(input, init);
+    };
+
+    function callService(namespace, procedure, args) {
+      const id = Date.now() + '-' + Math.random().toString(36).slice(2, 10);
+      return new Promise((resolve) => {
+        pendingServices.set(id, resolve);
+        vscode.postMessage({
+          type: 'serviceCall',
+          payload: { id, namespace, procedure, args },
+        });
+      });
+    }
+
+    window.addEventListener('message', (event) => {
+      const message = event.data;
+      if (!message) return;
+      if (message.type === 'updateFile') {
+        const payload = message.payload || {};
+        output.textContent = payload.text || 'No content.';
+        const code = payload.text || '';
+        compileAndMount(code);
+        return;
+      }
+      if (message.type === 'serviceResult') {
+        const payload = message.payload || {};
+        const handler = pendingServices.get(payload.id);
+        if (handler) {
+          pendingServices.delete(payload.id);
+          handler(payload);
+        }
+        return;
+      }
+      if (message.type === 'editHistorySet') {
+        const payload = message.payload || {};
+        renderHistory(payload.entries || []);
+        return;
+      }
+      if (message.type === 'editHistoryToggle') {
+        toggleHistory();
+        return;
+      }
+      if (message.type === 'setServices') {
+        const payload = message.payload || {};
+        serviceNamespaces = payload.namespaces || [];
+        if (servicesLabel) {
+          const count = serviceNamespaces.length;
+          servicesLabel.textContent = count === 0
+            ? 'No services'
+            : 'Services: ' + serviceNamespaces.join(', ');
+        }
+        return;
+      }
+      if (message.type === 'editProgress') {
+        const payload = message.payload || {};
+        if (payload.chunk) {
+          editBuffer += payload.chunk;
+        }
+        if (payload.done) {
+          output.textContent = editBuffer || output.textContent;
+          editBuffer = '';
+          if (status) status.textContent = 'Applied.';
+        }
+        return;
+      }
+      if (message.type === 'editError') {
+        const payload = message.payload || {};
+        setError(payload.message || 'Edit failed');
+        if (status) status.textContent = 'Failed.';
+      }
+    });
+
+    const form = document.getElementById('edit-form');
+    const input = document.getElementById('edit-input');
+    const submit = document.getElementById('edit-submit');
+    const status = document.getElementById('edit-status');
+    const historyToggle = document.getElementById('history-toggle');
+    const historyPanel = document.getElementById('history-panel');
+    const historyList = document.getElementById('history-list');
+
+    form?.addEventListener('submit', (event) => {
+      event.preventDefault();
+      const prompt = input?.value?.trim();
+      if (!prompt) return;
+      if (status) status.textContent = 'Editing...';
+      editBuffer = '';
+      vscode.postMessage({
+        type: 'editRequest',
+        payload: { prompt },
+      });
+      if (input) input.value = '';
+    });
+
+    historyToggle?.addEventListener('click', () => {
+      toggleHistory();
+      vscode.postMessage({ type: 'editHistoryToggle' });
+    });
+
+    function toggleHistory() {
+      if (!historyPanel) return;
+      historyPanel.hidden = !historyPanel.hidden;
+    }
+
+    function renderHistory(entries) {
+      if (!historyList) return;
+      historyList.innerHTML = '';
+      if (!entries || entries.length === 0) {
+        const empty = document.createElement('div');
+        empty.className = 'history-item';
+        empty.textContent = 'No edits yet.';
+        historyList.appendChild(empty);
+        return;
+      }
+      entries.forEach((entry) => {
+        const item = document.createElement('div');
+        item.className = 'history-item';
+        const prompt = document.createElement('div');
+        prompt.className = 'history-prompt';
+        prompt.textContent = entry.prompt || 'Edit';
+        const summary = document.createElement('div');
+        summary.className = 'history-summary';
+        summary.textContent = entry.summary || '';
+        item.appendChild(prompt);
+        item.appendChild(summary);
+        historyList.appendChild(item);
+      });
+    }
+
+    vscode.postMessage({ type: 'ready' });
+  </script>
+</body>
+</html>`;
+  }
+  getNonce() {
+    let text = "";
+    const possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    for (let i = 0; i < 32; i += 1) {
+      text += possible.charAt(Math.floor(Math.random() * possible.length));
+    }
+    return text;
+  }
+  isPreviewableDocument(document) {
+    const ext = path.extname(document.uri.path).toLowerCase();
+    return ext === ".tsx" || ext === ".jsx";
+  }
+};
+
+// src/services/EditService.ts
+var import_openai_compatible = require("@ai-sdk/openai-compatible");
+var import_ai = require("ai");
+var import_stitchery = require("@aprovan/stitchery");
+var EditService = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  async *streamEdit(code, prompt) {
+    const provider = (0, import_openai_compatible.createOpenAICompatible)({
+      name: "copilot-proxy",
+      baseURL: this.baseUrl
+    });
+    const result = (0, import_ai.streamText)({
+      model: provider("claude-opus-4.5"),
+      system: `Current component code:
+\`\`\`tsx
+${code}
+\`\`\`
+
+${import_stitchery.EDIT_PROMPT}`,
+      messages: [{ role: "user", content: prompt }]
+    });
+    for await (const chunk of result.textStream) {
+      yield chunk;
+    }
+  }
+};
+
+// src/services/EmbeddedStitchery.ts
+var import_mcp = require("@ai-sdk/mcp");
+var import_mcp_stdio = require("@ai-sdk/mcp/mcp-stdio");
+var import_patchwork_utcp = require("@aprovan/patchwork-utcp");
+var import_stitchery2 = require("@aprovan/stitchery");
+var EmbeddedStitchery = class {
+  registry = new import_stitchery2.ServiceRegistry();
+  async initialize(config = {}) {
+    this.registry = new import_stitchery2.ServiceRegistry();
+    const { utcp, mcpServers = [] } = config;
+    if (mcpServers.length > 0) {
+      await this.initMcpTools(mcpServers);
+    }
+    if (utcp) {
+      try {
+        const { backend, toolInfos } = await (0, import_patchwork_utcp.createUtcpBackend)(
+          utcp,
+          utcp.cwd
+        );
+        this.registry.registerBackend(backend, toolInfos);
+      } catch (error) {
+        console.error("[patchwork-vscode] UTCP init failed:", error);
+      }
+    }
+  }
+  async handleServiceCall(msg) {
+    try {
+      const result = await this.registry.call(
+        msg.namespace,
+        msg.procedure,
+        msg.args
+      );
+      return { id: msg.id, result };
+    } catch (error) {
+      return {
+        id: msg.id,
+        error: error instanceof Error ? error.message : "Service call failed"
+      };
+    }
+  }
+  getNamespaces() {
+    return this.registry.getNamespaces();
+  }
+  async initMcpTools(servers) {
+    for (const server of servers) {
+      const client = await (0, import_mcp.createMCPClient)({
+        transport: new import_mcp_stdio.Experimental_StdioMCPTransport({
+          command: server.command,
+          args: server.args
+        })
+      });
+      this.registry.registerTools(await client.tools(), server.name);
+    }
+  }
+};
+
+// src/extension.ts
+function activate(context) {
+  const treeProvider = new PatchworkTreeProvider();
+  const fileSystemProvider = new PatchworkFileSystemProvider();
+  const diagnostics = vscode4.languages.createDiagnosticCollection("patchwork");
+  const projectRoots = /* @__PURE__ */ new Map();
+  const projects = /* @__PURE__ */ new Map();
+  const editHistory = /* @__PURE__ */ new Map();
+  const embeddedStitchery = new EmbeddedStitchery();
+  const statusBar = vscode4.window.createStatusBarItem(
+    vscode4.StatusBarAlignment.Right
+  );
+  statusBar.command = "patchwork.testConnection";
+  statusBar.tooltip = "Patchwork: Copilot proxy status";
+  statusBar.show();
+  const previewProvider = new PreviewPanelProvider(context, {
+    onCompileError: (payload, document) => {
+      if (!document) return;
+      diagnostics.set(document.uri, toDiagnostics(payload, document));
+    },
+    onCompileSuccess: (document) => {
+      if (!document) return;
+      diagnostics.delete(document.uri);
+    },
+    onEditRequest: async (payload, document) => {
+      if (!document) return;
+      const request = parseEditRequest(payload);
+      if (!request) return;
+      await runEditRequest(
+        request.prompt,
+        document,
+        previewProvider,
+        editHistory
+      );
+    },
+    onServiceCall: async (payload) => {
+      const call = parseServiceCall(payload);
+      if (!call) return;
+      const result = await embeddedStitchery.handleServiceCall(call);
+      previewProvider.postMessage({ type: "serviceResult", payload: result });
+    },
+    onWebviewReady: () => {
+      previewProvider.postMessage({
+        type: "setServices",
+        payload: { namespaces: embeddedStitchery.getNamespaces() }
+      });
+      const doc = vscode4.window.activeTextEditor?.document;
+      if (doc) {
+        previewProvider.postMessage({
+          type: "editHistorySet",
+          payload: { entries: getHistoryForDoc(editHistory, doc) }
+        });
+      }
+    }
+  });
+  context.subscriptions.push(
+    vscode4.window.registerTreeDataProvider("patchworkExplorer", treeProvider)
+  );
+  context.subscriptions.push(diagnostics);
+  context.subscriptions.push(statusBar);
+  context.subscriptions.push(
+    vscode4.workspace.registerFileSystemProvider(
+      "patchwork",
+      fileSystemProvider,
+      { isCaseSensitive: true }
+    )
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand("patchwork.openProject", async () => {
+      const selection = await vscode4.window.showOpenDialog({
+        canSelectFolders: true,
+        canSelectFiles: false,
+        canSelectMany: false,
+        openLabel: "Open Patchwork Project"
+      });
+      const folderUri = selection?.[0];
+      if (!folderUri) return;
+      const project = await loadProjectFromFolder(folderUri);
+      if (!project) {
+        vscode4.window.showWarningMessage(
+          "Patchwork: no supported files found in the selected folder."
+        );
+        return;
+      }
+      treeProvider.setProject(project.id, project);
+      fileSystemProvider.setProject(project.id, project);
+      projectRoots.set(project.id, folderUri);
+      projects.set(project.id, project);
+      await vscode4.commands.executeCommand(
+        "patchwork.openFile",
+        project.id,
+        project.entry
+      );
+    })
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand("patchwork.showPreview", async () => {
+      const editor = vscode4.window.activeTextEditor;
+      if (!editor) {
+        vscode4.window.showInformationMessage(
+          "Patchwork: open a file to preview."
+        );
+        return;
+      }
+      previewProvider.showPreview(editor.document);
+    })
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand(
+      "patchwork.openFile",
+      async (projectId, filePath) => {
+        const uri = buildPatchworkUri(projectId, filePath);
+        await vscode4.commands.executeCommand("vscode.open", uri);
+      }
+    )
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand("patchwork.editWithAI", async () => {
+      const editor = vscode4.window.activeTextEditor;
+      if (!editor) {
+        vscode4.window.showInformationMessage("Patchwork: open a file to edit.");
+        return;
+      }
+      const prompt = await vscode4.window.showInputBox({
+        prompt: "Describe the edit you want"
+      });
+      if (!prompt) return;
+      await runEditRequest(
+        prompt,
+        editor.document,
+        previewProvider,
+        editHistory
+      );
+    })
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand("patchwork.showEditHistory", async () => {
+      previewProvider.postMessage({ type: "editHistoryToggle" });
+    })
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand("patchwork.testConnection", async () => {
+      const ok = await updateProxyStatus(statusBar);
+      if (ok) {
+        vscode4.window.showInformationMessage(
+          "Patchwork: Copilot proxy is reachable."
+        );
+      } else {
+        vscode4.window.showWarningMessage(
+          "Patchwork: Copilot proxy is unreachable."
+        );
+      }
+    })
+  );
+  context.subscriptions.push(
+    vscode4.commands.registerCommand("patchwork.exportProject", async () => {
+      if (projects.size === 0) {
+        vscode4.window.showInformationMessage(
+          "Patchwork: open a project before exporting."
+        );
+        return;
+      }
+      const projectId = await pickProjectId(projects);
+      if (!projectId) return;
+      const project = projects.get(projectId);
+      if (!project) return;
+      const target = await vscode4.window.showOpenDialog({
+        canSelectFolders: true,
+        canSelectFiles: false,
+        canSelectMany: false,
+        openLabel: "Export Patchwork Project"
+      });
+      const targetDir = target?.[0];
+      if (!targetDir) return;
+      await exportProject(project, targetDir);
+      vscode4.window.showInformationMessage(
+        `Patchwork: exported ${project.id}.`
+      );
+    })
+  );
+  context.subscriptions.push(
+    vscode4.window.onDidChangeActiveTextEditor((editor) => {
+      if (!editor) return;
+      previewProvider.updateDocument(editor.document);
+      previewProvider.postMessage({
+        type: "editHistorySet",
+        payload: { entries: getHistoryForDoc(editHistory, editor.document) }
+      });
+    })
+  );
+  context.subscriptions.push(
+    vscode4.languages.registerCodeActionsProvider(
+      ["typescriptreact", "javascriptreact"],
+      {
+        provideCodeActions(document, range) {
+          const action = new vscode4.CodeAction(
+            "Edit with Patchwork AI",
+            vscode4.CodeActionKind.QuickFix
+          );
+          action.command = {
+            command: "patchwork.editWithAI",
+            title: "Edit with Patchwork AI",
+            arguments: [document.uri, range]
+          };
+          return [action];
+        }
+      },
+      {
+        providedCodeActionKinds: [vscode4.CodeActionKind.QuickFix]
+      }
+    )
+  );
+  context.subscriptions.push(
+    vscode4.workspace.onDidSaveTextDocument(async (document) => {
+      if (document.uri.scheme !== "patchwork") return;
+      const parsed = parsePatchworkUri(document.uri);
+      if (!parsed) return;
+      const root = projectRoots.get(parsed.projectId);
+      if (!root) return;
+      await writeProjectFile(root, parsed.filePath, document.getText());
+    })
+  );
+  context.subscriptions.push(
+    vscode4.workspace.onDidChangeTextDocument((event) => {
+      const editor = vscode4.window.activeTextEditor;
+      if (!editor) return;
+      if (event.document !== editor.document) return;
+      previewProvider.updateDocument(event.document);
+    })
+  );
+  context.subscriptions.push(
+    vscode4.workspace.onDidChangeConfiguration((event) => {
+      if (event.affectsConfiguration("patchwork.copilotProxyUrl")) {
+        void updateProxyStatus(statusBar);
+      }
+      if (event.affectsConfiguration("patchwork.mcpServers") || event.affectsConfiguration("patchwork.utcpConfig")) {
+        void initializeEmbeddedStitchery(embeddedStitchery, previewProvider);
+      }
+    })
+  );
+  void updateProxyStatus(statusBar);
+  void initializeEmbeddedStitchery(embeddedStitchery, previewProvider);
+}
+function deactivate() {
+}
+async function loadProjectFromFolder(folderUri) {
+  const files = [];
+  const ignoredDirs = /* @__PURE__ */ new Set([
+    ".git",
+    "node_modules",
+    ".turbo",
+    "dist",
+    "build",
+    ".next",
+    ".cache"
+  ]);
+  const ignoredFiles = /* @__PURE__ */ new Set([".DS_Store"]);
+  const walk = async (dirUri) => {
+    const entries = await vscode4.workspace.fs.readDirectory(dirUri);
+    for (const [name, type] of entries) {
+      if (type === vscode4.FileType.Directory && ignoredDirs.has(name)) {
+        continue;
+      }
+      if (type === vscode4.FileType.File && ignoredFiles.has(name)) {
+        continue;
+      }
+      const entryUri = vscode4.Uri.joinPath(dirUri, name);
+      if (type === vscode4.FileType.Directory) {
+        await walk(entryUri);
+        continue;
+      }
+      if (type !== vscode4.FileType.File) continue;
+      const bytes = await vscode4.workspace.fs.readFile(entryUri);
+      const hasNull = bytes.some((value) => value === 0);
+      const content = hasNull ? Buffer.from(bytes).toString("base64") : Buffer.from(bytes).toString("utf8");
+      const relative2 = path2.relative(folderUri.fsPath, entryUri.fsPath).split(path2.sep).join("/");
+      files.push({
+        path: relative2,
+        content,
+        encoding: hasNull ? "base64" : "utf8"
+      });
+    }
+  };
+  await walk(folderUri);
+  if (files.length === 0) return null;
+  const projectId = path2.basename(folderUri.fsPath);
+  return (0, import_patchwork_compiler.createProjectFromFiles)(files, projectId);
+}
+function buildPatchworkUri(projectId, filePath) {
+  return vscode4.Uri.parse(`patchwork://${projectId}/${filePath}`);
+}
+function parsePatchworkUri(uri) {
+  if (uri.scheme !== "patchwork") return null;
+  const projectId = uri.authority;
+  const filePath = uri.path.replace(/^\/+/, "");
+  if (!projectId || !filePath) return null;
+  return { projectId, filePath };
+}
+async function writeProjectFile(root, filePath, content) {
+  const segments = filePath.split("/");
+  const target = vscode4.Uri.joinPath(root, ...segments);
+  if (segments.length > 1) {
+    const dir = vscode4.Uri.joinPath(root, ...segments.slice(0, -1));
+    await vscode4.workspace.fs.createDirectory(dir);
+  }
+  await vscode4.workspace.fs.writeFile(target, Buffer.from(content, "utf8"));
+}
+async function exportProject(project, targetDir) {
+  for (const [filePath, file] of project.files) {
+    const segments = filePath.split("/");
+    const target = vscode4.Uri.joinPath(targetDir, ...segments);
+    if (segments.length > 1) {
+      const dir = vscode4.Uri.joinPath(targetDir, ...segments.slice(0, -1));
+      await vscode4.workspace.fs.createDirectory(dir);
+    }
+    const content = file.encoding === "base64" ? Buffer.from(file.content, "base64") : Buffer.from(file.content, "utf8");
+    await vscode4.workspace.fs.writeFile(target, content);
+  }
+}
+async function pickProjectId(projects) {
+  if (projects.size === 1) {
+    return projects.keys().next().value;
+  }
+  const options = Array.from(projects.keys()).sort();
+  return vscode4.window.showQuickPick(options, {
+    placeHolder: "Select a Patchwork project"
+  });
+}
+function toDiagnostics(payload, document) {
+  const data = payload && typeof payload === "object" ? payload : {};
+  const message = typeof data.message === "string" ? data.message : "Patchwork compile error";
+  const line = typeof data.line === "number" ? data.line : 1;
+  const column = typeof data.column === "number" ? data.column : 1;
+  const position = new vscode4.Position(
+    clampLine(line - 1, document),
+    Math.max(0, column - 1)
+  );
+  const range = new vscode4.Range(position, position);
+  const diagnostic = new vscode4.Diagnostic(
+    range,
+    message,
+    vscode4.DiagnosticSeverity.Error
+  );
+  return [diagnostic];
+}
+async function updateProxyStatus(statusBar) {
+  statusBar.text = "$(sync~spin) Patchwork";
+  const config = vscode4.workspace.getConfiguration("patchwork");
+  const baseUrl = config.get(
+    "copilotProxyUrl",
+    "http://localhost:3000"
+  );
+  try {
+    const response = await fetch(`${baseUrl}/health`);
+    if (response.ok) {
+      statusBar.text = "$(plug) Patchwork";
+      statusBar.tooltip = "Copilot Proxy: Connected";
+      return true;
+    }
+  } catch {
+  }
+  statusBar.text = "$(debug-disconnect) Patchwork";
+  statusBar.tooltip = "Copilot Proxy: Disconnected";
+  return false;
+}
+function clampLine(line, document) {
+  const maxLine = Math.max(0, document.lineCount - 1);
+  return Math.min(Math.max(0, line), maxLine);
+}
+function parseEditRequest(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const data = payload;
+  if (typeof data.prompt !== "string" || !data.prompt.trim()) return null;
+  return { prompt: data.prompt.trim() };
+}
+function parseServiceCall(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const data = payload;
+  const id = typeof data.id === "string" ? data.id : null;
+  const namespace = typeof data.namespace === "string" ? data.namespace : null;
+  const procedure = typeof data.procedure === "string" ? data.procedure : null;
+  const args = data.args && typeof data.args === "object" ? data.args : {};
+  if (!id || !namespace || !procedure) return null;
+  return { id, namespace, procedure, args };
+}
+async function runEditRequest(prompt, document, previewProvider, historyStore) {
+  const history = getHistoryForDoc(historyStore, document);
+  const editService = createEditService();
+  let combined = "";
+  previewProvider.postMessage({
+    type: "editProgress",
+    payload: { chunk: "", done: false }
+  });
+  try {
+    for await (const chunk of editService.streamEdit(
+      document.getText(),
+      prompt
+    )) {
+      combined += chunk;
+      previewProvider.postMessage({
+        type: "editProgress",
+        payload: { chunk, done: false }
+      });
+    }
+    const updated = extractEditedCode(combined);
+    await applyDocumentEdit(document, updated);
+    history.push({ prompt, summary: summarizeEdit(combined) });
+    setHistoryForDoc(historyStore, document, history);
+    previewProvider.postMessage({
+      type: "editHistorySet",
+      payload: { entries: history }
+    });
+    previewProvider.postMessage({
+      type: "editProgress",
+      payload: { chunk: "", done: true }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Edit failed";
+    previewProvider.postMessage({
+      type: "editError",
+      payload: { message }
+    });
+    vscode4.window.showErrorMessage(`Patchwork edit failed: ${message}`);
+  }
+}
+function createEditService() {
+  const config = vscode4.workspace.getConfiguration("patchwork");
+  const baseUrl = config.get(
+    "copilotProxyUrl",
+    "http://localhost:3000"
+  );
+  return new EditService(baseUrl);
+}
+function extractEditedCode(response) {
+  const fence = response.match(/```[a-zA-Z0-9]*\n([\s\S]*?)```/);
+  if (fence && fence[1]) {
+    return fence[1].trimEnd();
+  }
+  return response.trimEnd();
+}
+function summarizeEdit(response) {
+  const cleaned = response.replace(/```[\s\S]*?```/g, "").trim();
+  if (!cleaned) return "Edit applied.";
+  const firstLine = cleaned.split("\n").find((line) => line.trim());
+  return (firstLine ?? "Edit applied.").slice(0, 200);
+}
+function getHistoryForDoc(history, document) {
+  return history.get(document.uri.toString()) ?? [];
+}
+function setHistoryForDoc(history, document, entries) {
+  history.set(document.uri.toString(), entries);
+}
+async function applyDocumentEdit(document, text) {
+  const editor = await vscode4.window.showTextDocument(document, {
+    preserveFocus: true,
+    preview: false
+  });
+  const fullRange = new vscode4.Range(
+    document.positionAt(0),
+    document.positionAt(document.getText().length)
+  );
+  await editor.edit((builder) => {
+    builder.replace(fullRange, text);
+  });
+}
+async function initializeEmbeddedStitchery(embeddedStitchery, previewProvider) {
+  const config = vscode4.workspace.getConfiguration("patchwork");
+  const mcpServers = config.get("mcpServers");
+  const utcp = config.get("utcpConfig");
+  await embeddedStitchery.initialize({
+    mcpServers: (mcpServers ?? []).map((server) => ({
+      name: server.name,
+      command: server.command,
+      args: server.args ?? []
+    })),
+    utcp
+  });
+  previewProvider.postMessage({
+    type: "setServices",
+    payload: { namespaces: embeddedStitchery.getNamespaces() }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate,
+  deactivate
+});
+//# sourceMappingURL=extension.js.map