zen-code 4.7.4 → 4.8.0

package/dist/shallow-checkpoint-BEhTdp7z-DfHxnfoU.mjs

@@ -1,383 +0,0 @@
-import { Kysely as L, sql as p } from "kysely";
-import { B as S, g as x, T as f, u as O, c as R, W as v, m as C } from "./app-CK3nD8Gj.mjs";
-import "./graphBuilder-DJoMXf6J.mjs";
-const u = {
-  maxRetries: 3,
-  baseDelayMs: 100,
-  isRetryableError: (h) => {
-    const e = h?.message?.toLowerCase() || "";
-    return e.includes("sqlite_busy") || e.includes("database is locked") || e.includes("database disk image is malformed") || e === "sqlite_busy" || e === "database is locked";
-  }
-};
-async function b(h, e) {
-  let s = null;
-  for (let c = 0; c < u.maxRetries; c++)
-    try {
-      return await h();
-    } catch (t) {
-      if (s = t, !u.isRetryableError(t))
-        throw t;
-      if (c < u.maxRetries - 1) {
-        const n = u.baseDelayMs * Math.pow(2, c);
-        console.warn(
-          `SQLite lock detected${e ? ` (${e})` : ""}, retrying in ${n}ms (attempt ${c + 1}/${u.maxRetries})`
-        ), await new Promise((i) => setTimeout(i, n));
-      }
-    }
-  throw s;
-}
-function g(h) {
-  if (h === null || typeof h != "object")
-    return JSON.stringify(h);
-  if (Array.isArray(h))
-    return JSON.stringify(h.map((c) => g(c)));
-  const e = {}, s = Object.keys(h).sort();
-  for (const c of s)
-    e[c] = h[c];
-  return JSON.stringify(e, (c, t) => {
-    if (t !== null && typeof t == "object" && !Array.isArray(t)) {
-      const n = {}, i = Object.keys(t).sort();
-      for (const r of i)
-        n[r] = t[r];
-      return n;
-    }
-    return t;
-  });
-}
-class N extends S {
-  db;
-  isSetup;
-  constructor(e, s) {
-    super(s), this.db = new L({
-      dialect: e
-    }), this.isSetup = !1;
-  }
-  static async fromConnStringAsync(e) {
-    let s;
-    if (globalThis.Bun) {
-      console.log("LG | Using BunWorkerDialect " + e);
-      const { BunWorkerDialect: c } = await import("kysely-bun-worker");
-      s = new N(new c({ url: e }));
-    } else {
-      console.log("LG | Using NodeWasmDialect");
-      const { default: c } = await import("node-sqlite3-wasm"), { NodeWasmDialect: t } = await import("kysely-wasm");
-      console.log(e);
-      const n = new t({
-        database: new c.Database(e)
-      });
-      s = new N(n);
-    }
-    return await s.setup(), s;
-  }
-  async setup() {
-    this.isSetup || (await p`PRAGMA busy_timeout = 5000`.execute(this.db), await p`PRAGMA journal_mode = WAL`.execute(this.db), await p`PRAGMA synchronous = NORMAL`.execute(this.db), await p`PRAGMA wal_autocheckpoint = 1000`.execute(this.db), await p`
-CREATE TABLE IF NOT EXISTS shallow_checkpoints (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  parent_checkpoint_id TEXT,
-  type TEXT,
-  checkpoint BLOB,
-  metadata BLOB,
-  checkpoint_ts INTEGER NOT NULL DEFAULT 0,
-  PRIMARY KEY (thread_id, checkpoint_ns)
-)`.execute(this.db), await p`
-CREATE INDEX IF NOT EXISTS idx_shallow_checkpoints_ts 
-ON shallow_checkpoints(checkpoint_ts DESC)`.execute(this.db), await p`
-CREATE TABLE IF NOT EXISTS writes (
-  thread_id TEXT NOT NULL,
-  checkpoint_ns TEXT NOT NULL DEFAULT '',
-  checkpoint_id TEXT NOT NULL,
-  task_id TEXT NOT NULL,
-  idx INTEGER NOT NULL,
-  channel TEXT NOT NULL,
-  type TEXT,
-  value BLOB,
-  PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
-)`.execute(this.db), this.isSetup = !0);
-  }
-  /**
-   * 获取 checkpoint（便捷方法）
-   */
-  async get(e) {
-    return (await this.getTuple(e))?.checkpoint;
-  }
-  async getTuple(e) {
-    await this.setup();
-    const s = e.configurable?.thread_id, c = e.configurable?.checkpoint_ns ?? "", t = x(e);
-    if (s === void 0)
-      return;
-    let n = this.db.selectFrom("shallow_checkpoints").select([
-      "thread_id",
-      "checkpoint_ns",
-      "checkpoint_id",
-      "parent_checkpoint_id",
-      "type",
-      "checkpoint",
-      "metadata",
-      "checkpoint_ts",
-      p`(
-                    SELECT json_group_array(
-                        json_object(
-                            'task_id', pw.task_id,
-                            'channel', pw.channel,
-                            'type', pw.type,
-                            'value', CAST(pw.value AS TEXT)
-                        )
-                    )
-                    FROM writes as pw
-                    WHERE pw.thread_id = shallow_checkpoints.thread_id
-                        AND pw.checkpoint_ns = shallow_checkpoints.checkpoint_ns
-                        AND pw.checkpoint_id = shallow_checkpoints.checkpoint_id
-                )`.as("pending_writes"),
-      p`(
-                    SELECT json_group_array(
-                        json_object(
-                            'type', ps.type,
-                            'value', CAST(ps.value AS TEXT)
-                        )
-                    )
-                    FROM writes as ps
-                    WHERE ps.thread_id = shallow_checkpoints.thread_id
-                        AND ps.checkpoint_ns = shallow_checkpoints.checkpoint_ns
-                        AND ps.checkpoint_id = shallow_checkpoints.parent_checkpoint_id
-                        AND ps.channel = ${f}
-                    ORDER BY ps.idx
-                )`.as("pending_sends")
-    ]).where("thread_id", "=", s).where("checkpoint_ns", "=", c);
-    t && (n = n.where("checkpoint_id", "=", t));
-    const i = await n.executeTakeFirst();
-    if (!i || t && i.checkpoint_id !== t)
-      return;
-    const r = await Promise.all(
-      JSON.parse(i.pending_writes || "[]").map(async (d) => [
-        d.task_id,
-        d.channel,
-        await this.serde.loadsTyped(d.type ?? "json", d.value ?? "")
-      ])
-    ), a = await this.serde.loadsTyped(
-      i.type ?? "json",
-      new TextDecoder().decode(i.checkpoint)
-    );
-    a.v < 4 && i.parent_checkpoint_id != null && await this.migratePendingSends(a, i.thread_id, i.parent_checkpoint_id);
-    const _ = {
-      configurable: {
-        thread_id: i.thread_id,
-        checkpoint_ns: i.checkpoint_ns,
-        checkpoint_id: i.checkpoint_id
-      }
-    };
-    return {
-      checkpoint: a,
-      config: _,
-      metadata: await this.serde.loadsTyped(
-        i.type ?? "json",
-        new TextDecoder().decode(i.metadata)
-      ),
-      parentConfig: i.parent_checkpoint_id ? {
-        configurable: {
-          thread_id: i.thread_id,
-          checkpoint_ns: i.checkpoint_ns,
-          checkpoint_id: i.parent_checkpoint_id
-        }
-      } : void 0,
-      pendingWrites: r
-    };
-  }
-  async *list(e, s) {
-    await this.setup();
-    const { limit: c, before: t, filter: n } = s ?? {}, i = e.configurable?.thread_id, r = e.configurable?.checkpoint_ns;
-    let a = this.db.selectFrom("shallow_checkpoints").select([
-      "thread_id",
-      "checkpoint_ns",
-      "checkpoint_id",
-      "parent_checkpoint_id",
-      "type",
-      "checkpoint",
-      "metadata",
-      "checkpoint_ts",
-      p`(
-                    SELECT json_group_array(
-                        json_object(
-                            'task_id', pw.task_id,
-                            'channel', pw.channel,
-                            'type', pw.type,
-                            'value', CAST(pw.value AS TEXT)
-                        )
-                    )
-                    FROM writes as pw
-                    WHERE pw.thread_id = shallow_checkpoints.thread_id
-                        AND pw.checkpoint_ns = shallow_checkpoints.checkpoint_ns
-                        AND pw.checkpoint_id = shallow_checkpoints.checkpoint_id
-                )`.as("pending_writes")
-    ]);
-    i && (a = a.where("thread_id", "=", i)), r != null && (a = a.where("checkpoint_ns", "=", r)), t?.configurable?.checkpoint_id !== void 0 && (a = a.where("checkpoint_id", "<", t.configurable.checkpoint_id)), a = a.orderBy("checkpoint_ts", "desc");
-    const _ = await a.execute();
-    let d = 0;
-    for (const o of _) {
-      const w = await this.serde.loadsTyped(
-        o.type ?? "json",
-        new TextDecoder().decode(o.metadata)
-      );
-      if (n && !this._checkMetadataFilterMatch(w, n))
-        continue;
-      if (c !== void 0 && d >= c)
-        return;
-      const y = await Promise.all(
-        JSON.parse(o.pending_writes || "[]").map(async (l) => [
-          l.task_id,
-          l.channel,
-          await this.serde.loadsTyped(l.type ?? "json", l.value ?? "")
-        ])
-      ), k = await this.serde.loadsTyped(
-        o.type ?? "json",
-        new TextDecoder().decode(o.checkpoint)
-      );
-      k.v < 4 && o.parent_checkpoint_id != null && await this.migratePendingSends(k, o.thread_id, o.parent_checkpoint_id), d++, yield {
-        config: {
-          configurable: {
-            thread_id: o.thread_id,
-            checkpoint_ns: o.checkpoint_ns,
-            checkpoint_id: o.checkpoint_id
-          }
-        },
-        checkpoint: k,
-        metadata: w,
-        parentConfig: o.parent_checkpoint_id ? {
-          configurable: {
-            thread_id: o.thread_id,
-            checkpoint_ns: o.checkpoint_ns,
-            checkpoint_id: o.parent_checkpoint_id
-          }
-        } : void 0,
-        pendingWrites: y
-      };
-    }
-  }
-  /**
-   * Check metadata filter matches (with deep comparison support)
-   * Matches ShallowMemorySaver behavior
-   */
-  _checkMetadataFilterMatch(e, s) {
-    for (const [c, t] of Object.entries(s)) {
-      const n = e?.[c];
-      if (t === null) {
-        if (!(c in (e || {})) || n !== null)
-          return !1;
-      } else if (typeof t == "object" && !Array.isArray(t)) {
-        if (typeof n != "object" || n === null || g(t) !== g(n))
-          return !1;
-      } else if (n !== t)
-        return !1;
-    }
-    return !0;
-  }
-  async put(e, s, c, t) {
-    await this.setup();
-    const n = e.configurable?.thread_id, i = e.configurable?.checkpoint_ns ?? "", r = e.configurable?.checkpoint_id;
-    if (!n)
-      throw new Error("thread_id is required");
-    const a = s.id || O(0), _ = R(s), [[d, o], [w, y]] = await Promise.all([
-      this.serde.dumpsTyped(_),
-      this.serde.dumpsTyped(c)
-    ]);
-    if (d !== w)
-      throw new Error("Failed to serialize checkpoint and metadata to the same type.");
-    const k = n, l = i, T = a;
-    return await b(
-      async () => {
-        await this.db.transaction().execute(async (m) => {
-          const E = await m.selectFrom("shallow_checkpoints").select(["checkpoint_id"]).where("thread_id", "=", k).where("checkpoint_ns", "=", l).executeTakeFirst();
-          E && E.checkpoint_id !== T && await m.deleteFrom("writes").where("thread_id", "=", k).where("checkpoint_ns", "=", l).where("checkpoint_id", "=", E.checkpoint_id).execute(), await m.insertInto("shallow_checkpoints").values({
-            thread_id: k,
-            checkpoint_ns: l,
-            checkpoint_id: T,
-            parent_checkpoint_id: r ?? null,
-            type: d,
-            checkpoint: new Uint8Array(Buffer.from(o)),
-            metadata: new Uint8Array(Buffer.from(y)),
-            checkpoint_ts: Date.now()
-          }).onConflict(
-            (A) => A.columns(["thread_id", "checkpoint_ns"]).doUpdateSet({
-              checkpoint_id: T,
-              parent_checkpoint_id: r ?? null,
-              type: d,
-              checkpoint: new Uint8Array(Buffer.from(o)),
-              metadata: new Uint8Array(Buffer.from(y)),
-              checkpoint_ts: Date.now()
-            })
-          ).execute();
-        });
-      },
-      `put(${n}/${a})`
-    ), {
-      configurable: {
-        thread_id: n,
-        checkpoint_ns: i,
-        checkpoint_id: a
-      }
-    };
-  }
-  async putWrites(e, s, c) {
-    await this.setup();
-    const t = e.configurable?.thread_id, n = e.configurable?.checkpoint_ns ?? "", i = e.configurable?.checkpoint_id;
-    if (!t || !i)
-      throw new Error("thread_id and checkpoint_id are required");
-    const r = await Promise.all(
-      s.map(async (a, _) => {
-        const [d, o] = await this.serde.dumpsTyped(a[1]);
-        return {
-          thread_id: t,
-          checkpoint_ns: n,
-          checkpoint_id: i,
-          task_id: c,
-          idx: v[a[0]] ?? _,
-          channel: a[0],
-          type: d,
-          value: new Uint8Array(Buffer.from(o))
-        };
-      })
-    );
-    r.length !== 0 && await b(
-      async () => {
-        await this.db.transaction().execute(async (a) => {
-          await a.deleteFrom("writes").where("thread_id", "=", t).where("checkpoint_ns", "=", n).where("checkpoint_id", "=", i).where("task_id", "=", c).execute();
-          for (const _ of r)
-            await a.insertInto("writes").values(_).execute();
-        });
-      },
-      `putWrites(${t}/${i}/${c})`
-    );
-  }
-  async deleteThread(e) {
-    await b(
-      async () => {
-        await this.db.transaction().execute(async (s) => {
-          await s.deleteFrom("shallow_checkpoints").where("thread_id", "=", e).execute(), await s.deleteFrom("writes").where("thread_id", "=", e).execute();
-        });
-      },
-      `deleteThread(${e})`
-    );
-  }
-  async migratePendingSends(e, s, c) {
-    const t = await this.db.selectFrom("writes as ps").select([
-      "ps.checkpoint_id",
-      p`json_group_array(
-                    json_object(
-                        'type', ps.type,
-                        'value', CAST(ps.value AS TEXT)
-                    )
-                )`.as("pending_sends")
-    ]).where("ps.thread_id", "=", s).where("ps.checkpoint_id", "=", c).where("ps.channel", "=", f).orderBy("ps.idx").executeTakeFirst();
-    if (!t) return;
-    const n = e;
-    n.channel_values ??= {}, n.channel_values[f] = await Promise.all(
-      JSON.parse(t.pending_sends || "[]").map(
-        ({ type: i, value: r }) => this.serde.loadsTyped(i, r)
-      )
-    ), n.channel_versions[f] = Object.keys(e.channel_versions).length > 0 ? C(...Object.values(e.channel_versions)) : this.getNextVersion(void 0);
-  }
-}
-export {
-  N as SqliteShallowSaver
-};

package/dist/sqlite-adapter-oBA95xba-BrBWorSV.mjs

@@ -1,82 +0,0 @@
-import { sql as e } from "kysely";
-class N {
-  db;
-  pragmaPromise = null;
-  constructor(t) {
-    this.db = t;
-  }
-  /**
-   * 设置 SQLite PRAGMA 配置，解决锁问题
-   * 使用 Promise 缓存确保并发安全且只执行一次
-   */
-  ensurePragma() {
-    return this.pragmaPromise || (this.pragmaPromise = this.doEnsurePragma()), this.pragmaPromise;
-  }
-  async doEnsurePragma() {
-    await e`PRAGMA busy_timeout = 5000`.execute(this.db), await e`PRAGMA journal_mode = WAL`.execute(this.db), await e`PRAGMA synchronous = NORMAL`.execute(this.db), await e`PRAGMA wal_autocheckpoint = 1000`.execute(this.db);
-  }
-  dateToDb(t) {
-    return t.toISOString();
-  }
-  dbToDate(t) {
-    return new Date(t);
-  }
-  jsonToDb(t) {
-    return JSON.stringify(t);
-  }
-  dbToJson(t) {
-    if (typeof t == "string")
-      try {
-        return JSON.parse(t);
-      } catch {
-        return t;
-      }
-    return t;
-  }
-  buildJsonQuery(t, T, r, a) {
-    const i = `$.${r.includes("-") || r.includes(".") || r.includes(" ") ? `"${r}"` : r}`;
-    let s;
-    if (typeof a == "string" || typeof a == "number" ? s = a : typeof a == "boolean" ? s = a ? 1 : 0 : a === null ? s = null : s = JSON.stringify(a), a === null) {
-      const E = `"${r}":null`;
-      return e`
-                json_extract(${e.ref(T)}, ${e.lit(i)}) IS NULL
-                AND ${e.ref(T)} LIKE ${e.lit(`%${E}%`)}
-            `;
-    }
-    return e`json_extract(${e.ref(T)}, ${e.lit(i)}) = ${e.lit(s)}`;
-  }
-  now() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  async createTables(t) {
-    await this.ensurePragma(), await e`
-            CREATE TABLE IF NOT EXISTS threads (
-                thread_id TEXT PRIMARY KEY,
-                created_at TEXT NOT NULL,
-                updated_at TEXT NOT NULL,
-                metadata TEXT NOT NULL DEFAULT '{}',
-                status TEXT NOT NULL DEFAULT 'idle',
-                "values" TEXT,
-                interrupts TEXT NOT NULL DEFAULT '{}'
-            )
-        `.execute(t), await e`
-            CREATE TABLE IF NOT EXISTS runs (
-                run_id TEXT PRIMARY KEY,
-                thread_id TEXT NOT NULL,
-                assistant_id TEXT NOT NULL,
-                created_at TEXT NOT NULL,
-                updated_at TEXT NOT NULL,
-                status TEXT NOT NULL DEFAULT 'pending',
-                metadata TEXT NOT NULL DEFAULT '{}',
-                multitask_strategy TEXT NOT NULL DEFAULT 'reject',
-                FOREIGN KEY (thread_id) REFERENCES threads(thread_id) ON DELETE CASCADE
-            )
-        `.execute(t);
-  }
-  async createIndexes(t) {
-    await e`CREATE INDEX IF NOT EXISTS idx_threads_status ON threads(status)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_threads_created_at ON threads(created_at)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_threads_updated_at ON threads(updated_at)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_runs_thread_id ON runs(thread_id)`.execute(t), await e`CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status)`.execute(t);
-  }
-}
-export {
-  N as SQLiteAdapter
-};

package/dist/subTasks-DNjIN4eU.mjs

@@ -1,18 +0,0 @@
-import { getAgentListFromPackage as s, SubAgentsMiddleware as g } from "@langgraph-js/standard-agent";
-import { SubAgentsMiddleware as w, getAgentListFromPackage as S } from "@langgraph-js/standard-agent";
-import { l as i, m as o } from "./graphBuilder-DJoMXf6J.mjs";
-async function m(e) {
-  const t = await s(e);
-  return new g({
-    agents: t,
-    stateSchema: i,
-    async createAgent(a, r, n) {
-      return await o(r.subagent_id, e, n, {}, { parent_id: a });
-    }
-  });
-}
-export {
-  w as SubAgentsMiddleware,
-  m as createSubAgentsMiddleware,
-  S as getAgentListFromPackage
-};

package/dist/zen-code.mjs

@@ -1,3 +0,0 @@
-import "./MultiLineTextInput-CL8nm9nv.mjs";
-import "chalk";
-import "./app-CK3nD8Gj.mjs";

package/dist/zen-keyboard.mjs

@@ -1,13 +0,0 @@
-import { r as a, j as n, a as c, u as f, T as x } from "./MultiLineTextInput-CL8nm9nv.mjs";
-a(/* @__PURE__ */ n.jsx(l, {}));
-function l() {
-  const [r, u] = c.useState(`Press any key...
-`);
-  return f((i, o, p) => {
-    const t = ["\x1B[2J\x1B[H", "input:", JSON.stringify(i), "", "key:"], e = Object.entries(o).filter(([, s]) => s === !0);
-    for (const [s] of e)
-      t.push(`  ${s}: true`);
-    e.length === 0 && t.push("  (no true values)"), t.push(JSON.stringify(p, null, 2)), u(t.join(`
-`));
-  }), /* @__PURE__ */ n.jsx(x, { children: r });
-}