@wipcomputer/memory-crystal 0.7.34-alpha.2 → 0.7.34-alpha.3

package/dist/role.js

@@ -1,10 +1,162 @@
-import {
-  demoteToNode,
-  detectRole,
-  loadRoleState,
-  promoteToCore
-} from "./chunk-437F27T6.js";
-import "./chunk-DFQ72B7M.js";
+// src/role.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+
+// src/ldm.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+var HOME = process.env.HOME || "";
+var LDM_ROOT = join(HOME, ".ldm");
+function loadAgentConfig(id) {
+  const cfgPath = join(LDM_ROOT, "agents", id, "config.json");
+  try {
+    if (existsSync(cfgPath)) return JSON.parse(readFileSync(cfgPath, "utf-8"));
+  } catch {
+  }
+  return null;
+}
+function getAgentId(harnessHint) {
+  if (process.env.CRYSTAL_AGENT_ID) return process.env.CRYSTAL_AGENT_ID;
+  const agentsDir = join(LDM_ROOT, "agents");
+  if (existsSync(agentsDir)) {
+    try {
+      for (const d of readdirSync(agentsDir)) {
+        const cfg = loadAgentConfig(d);
+        if (!cfg || !cfg.agentId) continue;
+        if (!harnessHint) return cfg.agentId;
+        if (harnessHint === "claude-code" && cfg.harness === "claude-code-cli") return cfg.agentId;
+        if (harnessHint === "openclaw" && cfg.harness === "openclaw") return cfg.agentId;
+      }
+    } catch {
+    }
+  }
+  return harnessHint === "openclaw" ? "oc-lesa-mini" : "cc-mini";
+}
+function ldmPaths(agentId) {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, "agents", id);
+  return {
+    root: LDM_ROOT,
+    bin: join(LDM_ROOT, "bin"),
+    secrets: join(LDM_ROOT, "secrets"),
+    state: join(LDM_ROOT, "state"),
+    config: join(LDM_ROOT, "config.json"),
+    crystalDb: join(LDM_ROOT, "memory", "crystal.db"),
+    crystalLance: join(LDM_ROOT, "memory", "lance"),
+    agentRoot,
+    transcripts: join(agentRoot, "memory", "transcripts"),
+    sessions: join(agentRoot, "memory", "sessions"),
+    daily: join(agentRoot, "memory", "daily"),
+    journals: join(agentRoot, "memory", "journals"),
+    workspace: join(agentRoot, "memory", "workspace")
+  };
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+function resolveStatePath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.state, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "memory", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+function stateWritePath(filename) {
+  const paths = ldmPaths();
+  const dir = paths.state;
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return join(dir, filename);
+}
+function resolveSecretPath(filename) {
+  const paths = ldmPaths();
+  const ldmPath = join(paths.secrets, filename);
+  if (existsSync(ldmPath)) return ldmPath;
+  const legacyPath = join(LEGACY_OC_DIR, "secrets", filename);
+  if (existsSync(legacyPath)) return legacyPath;
+  return ldmPath;
+}
+
+// src/role.ts
+var STATE_FILE = "crystal-role.json";
+function loadRoleState() {
+  try {
+    const path = resolveStatePath(STATE_FILE);
+    if (existsSync2(path)) {
+      return JSON.parse(readFileSync2(path, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveRoleState(state) {
+  const writePath = stateWritePath(STATE_FILE);
+  writeFileSync2(writePath, JSON.stringify(state, null, 2) + "\n");
+}
+function hasLocalEmbeddingProvider() {
+  if (process.env.OPENAI_API_KEY) return true;
+  if (process.env.GOOGLE_API_KEY && process.env.CRYSTAL_EMBEDDING_PROVIDER === "google") return true;
+  if (process.env.CRYSTAL_EMBEDDING_PROVIDER === "ollama") return true;
+  return false;
+}
+function hasRelayKey() {
+  const keyPath = resolveSecretPath("crystal-relay-key");
+  return existsSync2(keyPath);
+}
+function detectRole() {
+  const agentId = getAgentId();
+  const paths = ldmPaths(agentId);
+  const relayUrl = process.env.CRYSTAL_RELAY_URL || null;
+  const relayToken = !!process.env.CRYSTAL_RELAY_TOKEN;
+  const relayKeyExists = hasRelayKey();
+  const localEmbeddings = hasLocalEmbeddingProvider();
+  const localDb = existsSync2(paths.crystalDb);
+  const state = loadRoleState();
+  if (state && state.override) {
+    return {
+      role: state.role,
+      source: "state-file",
+      relayUrl,
+      relayToken,
+      relayKeyExists,
+      agentId,
+      hasLocalEmbeddings: localEmbeddings,
+      hasLocalDb: localDb
+    };
+  }
+  let role = "core";
+  if ((relayUrl || relayKeyExists) && !localEmbeddings) {
+    role = "node";
+  } else if ((relayUrl || relayKeyExists) && localEmbeddings) {
+    role = "core";
+  }
+  return {
+    role,
+    source: "auto-detected",
+    relayUrl,
+    relayToken,
+    relayKeyExists,
+    agentId,
+    hasLocalEmbeddings: localEmbeddings,
+    hasLocalDb: localDb
+  };
+}
+function promoteToCore() {
+  saveRoleState({
+    role: "core",
+    override: true,
+    agentId: getAgentId(),
+    setAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function demoteToNode(relayUrl) {
+  saveRoleState({
+    role: "node",
+    override: true,
+    relayUrl,
+    agentId: getAgentId(),
+    setAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
 export {
   demoteToNode,
   detectRole,

package/dist/staging.js

@@ -1,14 +1,239 @@
+// src/staging.ts
 import {
-  ensureStaging,
-  hasStagedData,
-  isNewAgent,
-  listStagedAgents,
-  markReady,
-  processAllStaged,
-  processStagedAgent,
-  stagingPaths
-} from "./chunk-5I7GMRDN.js";
-import "./chunk-DFQ72B7M.js";
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  renameSync,
+  unlinkSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join2 } from "path";
+
+// src/ldm.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, chmodSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+var HOME = process.env.HOME || "";
+var LDM_ROOT = join(HOME, ".ldm");
+function loadAgentConfig(id) {
+  const cfgPath = join(LDM_ROOT, "agents", id, "config.json");
+  try {
+    if (existsSync(cfgPath)) return JSON.parse(readFileSync(cfgPath, "utf-8"));
+  } catch {
+  }
+  return null;
+}
+function getAgentId(harnessHint) {
+  if (process.env.CRYSTAL_AGENT_ID) return process.env.CRYSTAL_AGENT_ID;
+  const agentsDir = join(LDM_ROOT, "agents");
+  if (existsSync(agentsDir)) {
+    try {
+      for (const d of readdirSync(agentsDir)) {
+        const cfg = loadAgentConfig(d);
+        if (!cfg || !cfg.agentId) continue;
+        if (!harnessHint) return cfg.agentId;
+        if (harnessHint === "claude-code" && cfg.harness === "claude-code-cli") return cfg.agentId;
+        if (harnessHint === "openclaw" && cfg.harness === "openclaw") return cfg.agentId;
+      }
+    } catch {
+    }
+  }
+  return harnessHint === "openclaw" ? "oc-lesa-mini" : "cc-mini";
+}
+function ldmPaths(agentId) {
+  const id = agentId || getAgentId();
+  const agentRoot = join(LDM_ROOT, "agents", id);
+  return {
+    root: LDM_ROOT,
+    bin: join(LDM_ROOT, "bin"),
+    secrets: join(LDM_ROOT, "secrets"),
+    state: join(LDM_ROOT, "state"),
+    config: join(LDM_ROOT, "config.json"),
+    crystalDb: join(LDM_ROOT, "memory", "crystal.db"),
+    crystalLance: join(LDM_ROOT, "memory", "lance"),
+    agentRoot,
+    transcripts: join(agentRoot, "memory", "transcripts"),
+    sessions: join(agentRoot, "memory", "sessions"),
+    daily: join(agentRoot, "memory", "daily"),
+    journals: join(agentRoot, "memory", "journals"),
+    workspace: join(agentRoot, "memory", "workspace")
+  };
+}
+function loadConfig() {
+  const configPath = join(LDM_ROOT, "config.json");
+  try {
+    if (existsSync(configPath)) {
+      return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveConfig(config) {
+  const configPath = join(LDM_ROOT, "config.json");
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+function scaffoldLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  mkdirSync(join(paths.root, "memory"), { recursive: true });
+  mkdirSync(paths.crystalLance, { recursive: true });
+  mkdirSync(paths.bin, { recursive: true });
+  mkdirSync(paths.secrets, { recursive: true, mode: 448 });
+  mkdirSync(paths.state, { recursive: true });
+  mkdirSync(paths.transcripts, { recursive: true });
+  mkdirSync(paths.sessions, { recursive: true });
+  mkdirSync(paths.daily, { recursive: true });
+  mkdirSync(paths.journals, { recursive: true });
+  mkdirSync(paths.workspace, { recursive: true });
+  const id = agentId || getAgentId();
+  let config = loadConfig();
+  if (!config) {
+    config = {
+      version: "1.0.0",
+      agents: [id],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } else {
+    if (!config.agents.includes(id)) {
+      config.agents.push(id);
+    }
+    config.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  saveConfig(config);
+  return paths;
+}
+var LEGACY_OC_DIR = join(HOME, ".openclaw");
+function ensureLdm(agentId) {
+  const paths = ldmPaths(agentId);
+  if (existsSync(paths.transcripts) && existsSync(paths.config)) {
+    return paths;
+  }
+  return scaffoldLdm(agentId);
+}
+
+// src/staging.ts
+import { execSync as execSync2 } from "child_process";
+var HOME2 = process.env.HOME || "";
+var STAGING_ROOT = join2(HOME2, ".ldm", "staging");
+function stagingPaths(agentId) {
+  const root = join2(STAGING_ROOT, agentId);
+  return {
+    root,
+    transcripts: join2(root, "transcripts"),
+    readyFile: join2(root, "READY")
+  };
+}
+function ensureStaging(agentId) {
+  const paths = stagingPaths(agentId);
+  mkdirSync2(paths.transcripts, { recursive: true });
+  return paths;
+}
+function markReady(agentId) {
+  const paths = stagingPaths(agentId);
+  writeFileSync2(paths.readyFile, JSON.stringify({
+    markedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    agentId
+  }));
+}
+function isNewAgent(agentId) {
+  const paths = ldmPaths(agentId);
+  return !existsSync2(paths.agentRoot);
+}
+function hasStagedData(agentId) {
+  const paths = stagingPaths(agentId);
+  return existsSync2(paths.readyFile);
+}
+function listStagedAgents() {
+  if (!existsSync2(STAGING_ROOT)) return [];
+  const agents = [];
+  for (const entry of readdirSync2(STAGING_ROOT, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    if (existsSync2(join2(STAGING_ROOT, entry.name, "READY"))) {
+      agents.push(entry.name);
+    }
+  }
+  return agents;
+}
+async function processStagedAgent(agentId) {
+  const startTime = Date.now();
+  const staging = stagingPaths(agentId);
+  if (!existsSync2(staging.readyFile)) {
+    throw new Error(`No READY file for agent ${agentId}`);
+  }
+  const agentPaths = ensureLdm(agentId);
+  const stagedFiles = existsSync2(staging.transcripts) ? readdirSync2(staging.transcripts).filter((f) => f.endsWith(".jsonl")) : [];
+  if (stagedFiles.length === 0) {
+    unlinkSync(staging.readyFile);
+    return {
+      agentId,
+      transcriptsProcessed: 0,
+      backfillChunks: 0,
+      dreamWeaverRan: false,
+      durationMs: Date.now() - startTime
+    };
+  }
+  for (const file of stagedFiles) {
+    const src = join2(staging.transcripts, file);
+    const dest = join2(agentPaths.transcripts, file);
+    try {
+      renameSync(src, dest);
+    } catch {
+      const { copyFileSync: copyFileSync2 } = await import("fs");
+      copyFileSync2(src, dest);
+      unlinkSync(src);
+    }
+  }
+  let backfillChunks = 0;
+  let dreamWeaverRan = false;
+  try {
+    const output = execSync2(
+      `crystal backfill --agent ${agentId}`,
+      { encoding: "utf-8", timeout: 6e5 }
+    );
+    const match = output.match(/(\d+) chunks embedded/);
+    if (match) backfillChunks = parseInt(match[1], 10);
+  } catch (err) {
+    process.stderr.write(`[staging] backfill failed for ${agentId}: ${err.message}
+`);
+  }
+  try {
+    execSync2(
+      `crystal dream-weave --agent ${agentId} --mode full`,
+      { encoding: "utf-8", timeout: 6e5 }
+    );
+    dreamWeaverRan = true;
+  } catch (err) {
+    process.stderr.write(`[staging] dream-weave failed for ${agentId}: ${err.message}
+`);
+  }
+  try {
+    unlinkSync(staging.readyFile);
+  } catch {
+  }
+  return {
+    agentId,
+    transcriptsProcessed: stagedFiles.length,
+    backfillChunks,
+    dreamWeaverRan,
+    durationMs: Date.now() - startTime
+  };
+}
+async function processAllStaged() {
+  const agents = listStagedAgents();
+  const results = [];
+  for (const agentId of agents) {
+    try {
+      const result = await processStagedAgent(agentId);
+      results.push(result);
+    } catch (err) {
+      process.stderr.write(`[staging] failed to process ${agentId}: ${err.message}
+`);
+    }
+  }
+  return results;
+}
 export {
   ensureStaging,
   hasStagedData,

package/dist/summarize.js

@@ -1,8 +1,145 @@
-import {
-  formatSummaryMarkdown,
-  generateSessionSummary,
-  writeSummaryFile
-} from "./chunk-Y72C7F6O.js";
+// src/summarize.ts
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import https from "https";
+import http from "http";
+var SUMMARY_MODE = process.env.CRYSTAL_SUMMARY_MODE || "simple";
+var SUMMARY_PROVIDER = process.env.CRYSTAL_SUMMARY_PROVIDER || "openai";
+var SUMMARY_MODEL = process.env.CRYSTAL_SUMMARY_MODEL || "gpt-4o-mini";
+function generateSimpleSummary(messages) {
+  const firstUser = messages.find((m) => m.role === "user");
+  const title = firstUser ? firstUser.text.slice(0, 80).replace(/\n/g, " ").trim() : "Untitled Session";
+  const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+  const preview = messages.slice(0, 10).map((m) => {
+    const roleLabel = m.role === "user" ? "User" : "Assistant";
+    const snippet = m.text.slice(0, 200).replace(/\n/g, " ").trim();
+    return `**${roleLabel}:** ${snippet}${m.text.length > 200 ? "..." : ""}`;
+  }).join("\n\n");
+  const date = messages[0]?.timestamp?.slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return {
+    title,
+    slug,
+    summary: preview,
+    topics: [],
+    messageCount: messages.length,
+    date
+  };
+}
+async function generateLlmSummary(messages) {
+  const condensed = messages.slice(0, 30).map((m) => {
+    const roleLabel = m.role === "user" ? "User" : "Assistant";
+    const text = m.text.slice(0, 500);
+    return `${roleLabel}: ${text}`;
+  }).join("\n\n");
+  const prompt = `Summarize this conversation. Return JSON only, no markdown fences.
+
+Format:
+{"title": "short title", "slug": "url-safe-slug", "summary": "2-4 sentences", "topics": ["topic1", "topic2"]}
+
+Conversation:
+${condensed}`;
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    return generateSimpleSummary(messages);
+  }
+  try {
+    const body = JSON.stringify({
+      model: SUMMARY_MODEL,
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0.3,
+      max_tokens: 300
+    });
+    const result = await httpPost("https://api.openai.com/v1/chat/completions", body, {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    });
+    const parsed = JSON.parse(result);
+    const content = parsed.choices?.[0]?.message?.content || "";
+    const jsonStr = content.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const data = JSON.parse(jsonStr);
+    const date = messages[0]?.timestamp?.slice(0, 10) || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return {
+      title: data.title || "Untitled",
+      slug: (data.slug || "untitled").slice(0, 50),
+      summary: data.summary || "",
+      topics: data.topics || [],
+      messageCount: messages.length,
+      date
+    };
+  } catch {
+    return generateSimpleSummary(messages);
+  }
+}
+function httpPost(url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const client = parsed.protocol === "https:" ? https : http;
+    const req = client.request({
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname + parsed.search,
+      method: "POST",
+      headers: { ...headers, "Content-Length": Buffer.byteLength(body) },
+      timeout: 3e4
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve(data);
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+async function generateSessionSummary(messages) {
+  if (SUMMARY_MODE === "llm") {
+    return generateLlmSummary(messages);
+  }
+  return generateSimpleSummary(messages);
+}
+function formatSummaryMarkdown(summary, sessionId) {
+  const lines = [];
+  lines.push(`# ${summary.title}`);
+  lines.push("");
+  lines.push(`**Session:** ${sessionId}  **Date:** ${summary.date}  **Messages:** ${summary.messageCount}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(summary.summary);
+  if (summary.topics.length > 0) {
+    lines.push("");
+    lines.push("## Key Topics");
+    lines.push("");
+    for (const topic of summary.topics) {
+      lines.push(`- ${topic}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function writeSummaryFile(sessionsDir, summary, agentId, sessionId) {
+  if (!existsSync(sessionsDir)) mkdirSync(sessionsDir, { recursive: true });
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10);
+  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "-");
+  const filename = `${dateStr}--${timeStr}--${agentId}--${summary.slug}.md`;
+  const filepath = join(sessionsDir, filename);
+  const content = formatSummaryMarkdown(summary, sessionId);
+  writeFileSync(filepath, content);
+  return filepath;
+}
 export {
   formatSummaryMarkdown,
   generateSessionSummary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wipcomputer/memory-crystal",
-  "version": "0.7.34-alpha.2",
+  "version": "0.7.34-alpha.3",
   "description": "Sovereign memory system — local-first with ephemeral encrypted relay. Your memory, your machine, your rules.",
   "repository": {
     "type": "git",
@@ -32,8 +32,8 @@
   ],
   "scripts": {
     "prepublishOnly": "npm run build",
-    "build": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist && tsup src/worker.ts --format esm --outDir dist --no-dts && cp scripts/crystal-capture.sh scripts/ldm-backup.sh dist/",
-    "build:local": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist",
+    "build": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist --no-splitting && tsup src/worker.ts --format esm --outDir dist --no-dts --no-splitting && cp scripts/crystal-capture.sh scripts/ldm-backup.sh dist/",
+    "build:local": "tsup src/core.ts src/cli.ts src/mcp-server.ts src/openclaw.ts src/migrate.ts src/cc-hook.ts src/cc-poller.ts src/crypto.ts src/pair.ts src/poller.ts src/mirror-sync.ts src/file-sync.ts src/ldm.ts src/summarize.ts src/role.ts src/doctor.ts src/bridge.ts src/discover.ts src/bulk-copy.ts src/oc-backfill.ts src/dream-weaver.ts src/crystal-serve.ts src/staging.ts src/installer.ts --format esm --dts --outDir dist --no-splitting",
     "build:worker": "tsup src/worker.ts --format esm --outDir dist --no-dts",
     "build:cloud": "tsup src/worker-mcp.ts src/cloud-crystal.ts --format esm --outDir dist --no-dts",
     "deploy:cloud": "bash -c 'git diff --quiet HEAD -- src/ wrangler-mcp.toml || (echo \"ERROR: uncommitted changes. commit before deploying.\" && exit 1)' && wrangler deploy --config wrangler-mcp.toml",