artifacty 0.1.0

package/src/client/editor.js

@@ -0,0 +1,260 @@
+import { EditorView, basicSetup } from "codemirror";
+import { Compartment } from "@codemirror/state";
+import { html } from "@codemirror/lang-html";
+import { json } from "@codemirror/lang-json";
+import { markdown } from "@codemirror/lang-markdown";
+
+const messages = {
+  formatJson: "Format JSON",
+  validJson: "Valid JSON",
+  invalidJson: "Invalid JSON: {message}",
+  htmlPreview: "HTML preview",
+  markdownPreview: "Markdown preview",
+  plainText: "Plain text",
+  mode: "{format} editor",
+  ...(globalThis.ARTIFACTY_I18N || {})
+};
+
+const editorTheme = EditorView.theme({
+  "&": {
+    minHeight: "52vh",
+    border: "1px solid var(--line)",
+    borderRadius: "8px",
+    background: "var(--panel)"
+  },
+  ".cm-scroller": {
+    fontFamily: '"SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace',
+    fontSize: "13px",
+    lineHeight: "1.55"
+  },
+  ".cm-content": {
+    minHeight: "52vh"
+  },
+  ".cm-gutters": {
+    borderTopLeftRadius: "8px",
+    borderBottomLeftRadius: "8px"
+  }
+});
+
+for (const textarea of document.querySelectorAll("textarea[data-artifacty-editor]")) {
+  enhanceTextarea(textarea);
+}
+
+function enhanceTextarea(textarea) {
+  const form = textarea.closest("form");
+  const formatSelector = form?.querySelector("select[name='format']");
+  const fileNameInput = form?.querySelector("input[name='fileName']");
+  const language = new Compartment();
+  const shell = document.createElement("div");
+  shell.className = "codemirror-shell";
+  shell.setAttribute("data-enhanced", "true");
+
+  const toolbar = document.createElement("div");
+  toolbar.className = "editor-toolbar";
+
+  const status = document.createElement("span");
+  status.className = "editor-status";
+
+  const formatJsonButton = document.createElement("button");
+  formatJsonButton.type = "button";
+  formatJsonButton.className = "secondary-button";
+  formatJsonButton.textContent = messages.formatJson;
+
+  toolbar.append(formatJsonButton, status);
+  textarea.after(toolbar, shell);
+  textarea.classList.add("textarea-enhanced");
+
+  const preview = document.createElement("section");
+  preview.className = "editor-preview";
+  preview.setAttribute("aria-live", "polite");
+  shell.after(preview);
+
+  const currentFormat = () => detectFormat({
+    explicit: formatSelector?.value || textarea.dataset.editorFormat,
+    fileName: fileNameInput?.value || "",
+    content: view.state.doc.toString()
+  });
+
+  const view = new EditorView({
+    doc: textarea.value,
+    parent: shell,
+    extensions: [
+      basicSetup,
+      EditorView.lineWrapping,
+      editorTheme,
+      language.of(languageExtension(detectFormat({
+        explicit: formatSelector?.value || textarea.dataset.editorFormat,
+        fileName: fileNameInput?.value || "",
+        content: textarea.value
+      }))),
+      EditorView.updateListener.of((update) => {
+        if (update.docChanged) {
+          textarea.value = update.state.doc.toString();
+          updatePreview();
+        }
+      })
+    ]
+  });
+
+  const reconfigure = () => {
+    const format = currentFormat();
+    view.dispatch({ effects: language.reconfigure(languageExtension(format)) });
+    updateToolbar(format);
+    updatePreview();
+  };
+
+  formatSelector?.addEventListener("change", reconfigure);
+  fileNameInput?.addEventListener("input", reconfigure);
+  form?.addEventListener("submit", () => {
+    textarea.value = view.state.doc.toString();
+  });
+
+  formatJsonButton.addEventListener("click", () => {
+    const content = view.state.doc.toString();
+    try {
+      const formatted = JSON.stringify(JSON.parse(content), null, 2);
+      view.dispatch({
+        changes: { from: 0, to: view.state.doc.length, insert: formatted }
+      });
+      status.textContent = messages.validJson;
+    } catch (error) {
+      status.textContent = invalidJsonMessage(error);
+    }
+  });
+
+  updateToolbar(currentFormat());
+  updatePreview();
+
+  function updateToolbar(format) {
+    formatJsonButton.hidden = format !== "json";
+    status.textContent = formatLabel(format);
+  }
+
+  function updatePreview() {
+    const format = currentFormat();
+    const content = view.state.doc.toString();
+    preview.replaceChildren();
+    preview.dataset.format = format;
+
+    if (format === "html") {
+      const frame = document.createElement("iframe");
+      frame.className = "editor-preview-frame";
+      frame.setAttribute("sandbox", "allow-scripts allow-forms allow-popups");
+      frame.srcdoc = content;
+      preview.append(frame);
+      status.textContent = messages.htmlPreview;
+      return;
+    }
+
+    if (format === "json") {
+      const pre = document.createElement("pre");
+      try {
+        pre.textContent = JSON.stringify(JSON.parse(content), null, 2);
+        status.textContent = messages.validJson;
+      } catch (error) {
+        pre.textContent = content;
+        status.textContent = invalidJsonMessage(error);
+      }
+      preview.append(pre);
+      return;
+    }
+
+    if (format === "markdown") {
+      const article = document.createElement("article");
+      article.className = "artifact-doc";
+      article.innerHTML = markdownPreview(content);
+      preview.append(article);
+      status.textContent = messages.markdownPreview;
+      return;
+    }
+
+    const pre = document.createElement("pre");
+    pre.textContent = content;
+    preview.append(pre);
+    status.textContent = messages.plainText;
+  }
+}
+
+function languageExtension(format) {
+  if (format === "html") {
+    return html();
+  }
+  if (format === "json") {
+    return json();
+  }
+  if (format === "markdown") {
+    return markdown();
+  }
+  return [];
+}
+
+function detectFormat({ explicit, fileName, content }) {
+  if (["markdown", "html", "json", "text"].includes(explicit)) {
+    return explicit;
+  }
+
+  const lowerName = String(fileName || "").toLowerCase();
+  if (lowerName.endsWith(".html") || lowerName.endsWith(".htm")) {
+    return "html";
+  }
+  if (lowerName.endsWith(".md") || lowerName.endsWith(".markdown")) {
+    return "markdown";
+  }
+  if (lowerName.endsWith(".json")) {
+    return "json";
+  }
+
+  const trimmed = String(content || "").trimStart();
+  if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html") || trimmed.startsWith("<")) {
+    return "html";
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return "json";
+  }
+  if (/^#{1,6}\s/m.test(trimmed)) {
+    return "markdown";
+  }
+  return "text";
+}
+
+function formatLabel(format) {
+  const label = `${format[0].toUpperCase()}${format.slice(1)}`;
+  return messages.mode.replaceAll("{format}", label);
+}
+
+function invalidJsonMessage(error) {
+  return messages.invalidJson.replaceAll("{message}", error.message);
+}
+
+function markdownPreview(content) {
+  return String(content || "")
+    .split(/\r?\n/)
+    .map((line) => {
+      if (/^###\s+/.test(line)) {
+        return `<h3>${escapeHtml(line.replace(/^###\s+/, ""))}</h3>`;
+      }
+      if (/^##\s+/.test(line)) {
+        return `<h2>${escapeHtml(line.replace(/^##\s+/, ""))}</h2>`;
+      }
+      if (/^#\s+/.test(line)) {
+        return `<h1>${escapeHtml(line.replace(/^#\s+/, ""))}</h1>`;
+      }
+      if (/^[-*]\s+/.test(line)) {
+        return `<p>• ${escapeHtml(line.replace(/^[-*]\s+/, ""))}</p>`;
+      }
+      if (!line.trim()) {
+        return "<br>";
+      }
+      return `<p>${escapeHtml(line)}</p>`;
+    })
+    .join("");
+}
+
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}

package/src/lib/backup.js

@@ -0,0 +1,75 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createStore, loadIndex, writeIndex } from "./storage.js";
+
+export async function exportStore(store = createStore(), outputPath) {
+  if (!outputPath) {
+    throw new Error("export requires --file <path>");
+  }
+  const index = await loadIndex(store);
+  const artifacts = [];
+  for (const artifact of index.artifacts) {
+    const versions = [];
+    for (const version of artifact.versions) {
+      versions.push({
+        ...version,
+        content: await readFile(path.join(store.home, version.path), "utf8")
+      });
+    }
+    artifacts.push({ ...artifact, versions });
+  }
+
+  const bundle = {
+    schemaVersion: 1,
+    exportedAt: new Date().toISOString(),
+    artifacts
+  };
+  await mkdir(path.dirname(path.resolve(outputPath)), { recursive: true });
+  await writeFile(outputPath, `${JSON.stringify(bundle, null, 2)}\n`, "utf8");
+  return {
+    path: path.resolve(outputPath),
+    artifactCount: artifacts.length,
+    exportedAt: bundle.exportedAt
+  };
+}
+
+export async function importStore(store = createStore(), inputPath) {
+  if (!inputPath) {
+    throw new Error("import-store requires --file <path>");
+  }
+  const bundle = JSON.parse(await readFile(inputPath, "utf8"));
+  if (!Array.isArray(bundle.artifacts)) {
+    throw new Error("Invalid Artifacty backup: artifacts array missing");
+  }
+
+  const index = {
+    version: 3,
+    artifacts: []
+  };
+
+  for (const artifact of bundle.artifacts) {
+    const versions = [];
+    for (const version of artifact.versions || []) {
+      const cleanVersion = { ...version };
+      delete cleanVersion.content;
+      const content = version.content || "";
+      const absolutePath = path.join(store.home, cleanVersion.path);
+      await mkdir(path.dirname(absolutePath), { recursive: true });
+      await writeFile(absolutePath, content, "utf8");
+      versions.push(cleanVersion);
+    }
+    index.artifacts.push({ ...artifact, versions });
+  }
+
+  await writeIndex(store, index);
+  return {
+    path: path.resolve(inputPath),
+    artifactCount: index.artifacts.length,
+    importedAt: new Date().toISOString()
+  };
+}
+
+export function defaultBackupPath(store = createStore()) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  return path.join(store.home, "backups", `artifacty-${stamp}.json`);
+}

package/src/lib/check.js

@@ -0,0 +1,124 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+export const REQUIRED_MCP_TOOLS = [
+  "artifacty_create",
+  "artifacty_publish",
+  "artifacty_import",
+  "artifacty_list",
+  "artifacty_get",
+  "artifacty_update",
+  "artifacty_archive",
+  "artifacty_restore",
+  "artifacty_audit",
+  "artifacty_info"
+];
+
+export async function checkMcpTools(options = {}) {
+  const projectDir = path.resolve(options.projectDir || process.cwd());
+  const serverPath = path.resolve(options.serverPath || path.join(projectDir, "src", "mcp-server.js"));
+  const requiredTools = options.requiredTools || REQUIRED_MCP_TOOLS;
+  const timeoutMs = Number(options.timeout || 5000);
+  const client = spawnMcpClient({
+    serverPath,
+    timeoutMs,
+    env: {
+      ...process.env,
+      ...(options.url ? { ARTIFACTY_URL: options.url } : {}),
+      ...(options.home ? { ARTIFACTY_HOME: path.resolve(options.home) } : {})
+    }
+  });
+
+  try {
+    const initialized = await client.request("initialize", {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: "artifacty-check", version: "0.1.0" }
+    });
+    client.notify("notifications/initialized", {});
+    const listed = await client.request("tools/list", {});
+    const toolNames = (listed.tools || []).map((tool) => tool.name).sort();
+    const missingTools = requiredTools.filter((tool) => !toolNames.includes(tool));
+
+    return {
+      ok: missingTools.length === 0,
+      serverPath,
+      protocolVersion: initialized.protocolVersion,
+      toolCount: toolNames.length,
+      tools: toolNames,
+      missingTools
+    };
+  } finally {
+    client.close();
+  }
+}
+
+function spawnMcpClient({ serverPath, timeoutMs, env }) {
+  const child = spawn(process.execPath, [serverPath], {
+    cwd: path.dirname(path.dirname(serverPath)),
+    env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let nextId = 1;
+  let buffer = "";
+  let stderr = "";
+  const pending = new Map();
+
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    let newline = buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (line.trim()) {
+        const message = JSON.parse(line);
+        const entry = pending.get(message.id);
+        if (entry) {
+          clearTimeout(entry.timer);
+          pending.delete(message.id);
+          if (message.error) {
+            entry.reject(new Error(message.error.message));
+          } else {
+            entry.resolve(message.result);
+          }
+        }
+      }
+      newline = buffer.indexOf("\n");
+    }
+  });
+
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString("utf8");
+  });
+
+  child.on("exit", (code) => {
+    for (const entry of pending.values()) {
+      clearTimeout(entry.timer);
+      entry.reject(new Error(`MCP server exited with code ${code}: ${stderr.trim()}`));
+    }
+    pending.clear();
+  });
+
+  return {
+    request(method, params) {
+      const id = nextId;
+      nextId += 1;
+      const payload = { jsonrpc: "2.0", id, method, params };
+      const promise = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`Timed out waiting for MCP response to ${method}`));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+      });
+      child.stdin.write(`${JSON.stringify(payload)}\n`);
+      return promise;
+    },
+    notify(method, params) {
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+    },
+    close() {
+      child.kill("SIGTERM");
+    }
+  };
+}