nolo-cli 0.8.0-alpha.2 → 0.8.0-alpha.21

package/chunk-7KCUSYT2.js

@@ -0,0 +1,354 @@
+import {
+  readDbRecord,
+  writeAgentRecord
+} from "./chunk-SDJDLO5W.js";
+import {
+  buildSkillSummaryMarker
+} from "./chunk-VF4K2QE6.js";
+import {
+  buildSkillDocMarkdown
+} from "./chunk-VC6OZXO5.js";
+import {
+  createSpaceKey
+} from "./chunk-UAD2WT54.js";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerUrl
+} from "./chunk-ISNCLGUZ.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  DEFAULT_LOCAL_API_ORIGIN
+} from "./chunk-4SN6J65J.js";
+import {
+  NOLO_CLUSTER_SERVERS
+} from "./chunk-LCBAMY2M.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+
+// packages/cli/docPageHelpers.ts
+import { readFileSync } from "node:fs";
+import { ulid } from "ulid";
+function getCliArg(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 ? args[idx + 1] : void 0;
+}
+function readBodyArg(args, fallback = "") {
+  const bodyFile = getCliArg(args, "--body-file");
+  if (bodyFile !== void 0) {
+    return readFileSync(bodyFile, "utf8");
+  }
+  return getCliArg(args, "--body") ?? fallback;
+}
+function textToSlate(text) {
+  return text.split("\n").map((line) => ({
+    type: "paragraph",
+    children: [{ text: line }]
+  }));
+}
+function createPageId() {
+  return ulid();
+}
+function buildPageKey(userId, pageId) {
+  return `page-${userId}-${pageId}`;
+}
+function buildPageRecord(args) {
+  const { dbKey, pageId, title, spaceId, content, existing, meta, slateData } = args;
+  const now = Date.now();
+  const createdAt = typeof existing?.createdAt === "number" ? existing.createdAt : now;
+  const created = typeof existing?.created === "string" ? existing.created : new Date(createdAt).toISOString();
+  const nextRecord = {
+    ...existing ?? {},
+    id: existing?.id ?? pageId,
+    dbKey,
+    type: "page",
+    title,
+    spaceId,
+    content,
+    updatedAt: now,
+    createdAt,
+    created
+  };
+  if (meta !== void 0) {
+    if (meta === null) {
+      delete nextRecord.meta;
+    } else {
+      nextRecord.meta = meta;
+    }
+  }
+  if (slateData !== void 0) {
+    if (slateData === null) {
+      delete nextRecord.slateData;
+    } else {
+      nextRecord.slateData = slateData;
+    }
+  } else if (!existing?.slateData) {
+    nextRecord.slateData = textToSlate(content);
+  }
+  return nextRecord;
+}
+
+// packages/cli/docSkillHelpers.ts
+function normalizeSkillSeed(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function deterministicId(prefix, seed) {
+  let h = 2166136261;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  const suffix = h.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+function buildSkillDocId(input) {
+  return deterministicId("01SK", normalizeSkillSeed(input) || input);
+}
+function buildSkillPageKey(userId, skillId) {
+  return buildPageKey(userId, skillId);
+}
+function buildSkillPageRecord(args) {
+  const {
+    dbKey,
+    skillId,
+    title,
+    spaceId,
+    body,
+    skillConfig,
+    evalConfig,
+    workflowConfig,
+    existing
+  } = args;
+  return {
+    ...buildPageRecord({
+      dbKey,
+      pageId: skillId,
+      title,
+      spaceId,
+      content: buildSkillDocMarkdown({
+        body,
+        skillConfig,
+        evalConfig,
+        workflowConfig
+      }),
+      existing,
+      meta: {
+        ...existing?.meta ?? {},
+        kind: "skill",
+        skillConfig,
+        ...evalConfig ? { evalConfig } : {},
+        ...workflowConfig ? { workflowConfig } : {}
+      },
+      slateData: null
+    })
+  };
+}
+function parseJsonArg(raw, fallback) {
+  if (raw === void 0) return fallback;
+  return JSON.parse(raw);
+}
+
+// packages/cli/docSpaceHelpers.ts
+async function ensurePageAttachedToSpace(params) {
+  const { baseUrl, userId, authToken, spaceId, contentKey, title, skillSummary } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl
+  });
+  const now = Date.now();
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: {
+        ...spaceRecord.contents ?? {},
+        [contentKey]: {
+          ...spaceRecord.contents?.[contentKey] ?? {},
+          title,
+          type: "page",
+          contentKey,
+          ...skillSummary !== void 0 ? { skillSummary } : {},
+          updatedAt: now,
+          createdAt: spaceRecord.contents?.[contentKey]?.createdAt ?? now
+        }
+      },
+      updatedAt: now
+    }
+  });
+}
+async function removePageFromSpace(params) {
+  const { baseUrl, userId, authToken, spaceId, contentKey } = params;
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceRecord = await readDbRecord({
+    dbKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl
+  });
+  const nextContents = { ...spaceRecord.contents ?? {} };
+  delete nextContents[contentKey];
+  await writeAgentRecord({
+    agentKey: spaceKey,
+    authToken,
+    fetchImpl: fetch,
+    serverUrl: baseUrl,
+    userId,
+    record: {
+      ...spaceRecord,
+      contents: nextContents,
+      updatedAt: Date.now()
+    }
+  });
+}
+
+// packages/cli/docCommandShared.ts
+function hasHelpArg(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function normalizeBaseUrl(base) {
+  return normalizeServerOrigin(base);
+}
+function localBaseFromEnv(env) {
+  return normalizeBaseUrl(env.SCRIPT_LOCAL_BASE_URL || DEFAULT_LOCAL_API_ORIGIN);
+}
+function targetToBase(target, env) {
+  const normalized = asTrimmedLowercaseString(target);
+  if (normalized === "local") return localBaseFromEnv(env);
+  if (normalized === "main") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[0]);
+  if (normalized === "us") return normalizeBaseUrl(NOLO_CLUSTER_SERVERS[1]);
+  return normalizeBaseUrl(target);
+}
+function parseSyncTargets(raw, env) {
+  if (!raw) return void 0;
+  return raw.split(",").map((value) => value.trim()).filter(Boolean).filter((value) => value !== "none").map((value) => targetToBase(value, env));
+}
+function isLocalBaseUrl(baseUrl) {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+function resolveWriteTargets(args, env) {
+  const explicitSync = parseSyncTargets(readOption(args, "--sync"), env);
+  const targets = hasFlag(args, "--local-only") ? [localBaseFromEnv(env)] : explicitSync ?? [resolveServerUrl(args, env)];
+  const filtered = hasFlag(args, "--no-local") ? targets.filter((target) => !isLocalBaseUrl(target)) : targets;
+  return Array.from(new Set(filtered.map(normalizeBaseUrl)));
+}
+function readTitle(args) {
+  const valueFlags = /* @__PURE__ */ new Set([
+    "--title",
+    "--name",
+    "--description",
+    "--body",
+    "--body-file",
+    "--space",
+    "--id",
+    "--key",
+    "--kind",
+    "--sync",
+    "--tools",
+    "--required-skills",
+    "--recommended-skills",
+    "--preferred-agents",
+    "--trigger-mode",
+    "--budget-tier",
+    "--prompt-patch",
+    "--token",
+    "--server"
+  ]);
+  return readOption(args, "--title") ?? args.find((value, index) => {
+    if (index === 0) return false;
+    if (valueFlags.has(args[index - 1])) return false;
+    return !value.startsWith("-");
+  });
+}
+function resolveDocKind(args, fallback) {
+  if (hasFlag(args, "--page") || readOption(args, "--kind") === "page") return "page";
+  return fallback;
+}
+function requireTokenUser(args, env, dryRun) {
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken) || env.USER_ID || "";
+  if (!authToken && !dryRun) {
+    throw new Error("doc command requires an auth token. Pass --token or set AUTH_TOKEN.");
+  }
+  if (!userId && !dryRun) {
+    throw new Error("auth token does not contain userId. Pass a user-scoped token.");
+  }
+  return {
+    authToken,
+    userId: userId || "dry-run"
+  };
+}
+async function writePageRecord(args) {
+  await writeAgentRecord({
+    agentKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+    record: args.record
+  });
+  if (args.spaceId) {
+    await ensurePageAttachedToSpace({
+      baseUrl: args.serverUrl,
+      userId: args.userId,
+      authToken: args.authToken,
+      spaceId: args.spaceId,
+      contentKey: args.dbKey,
+      title: args.title,
+      skillSummary: args.skillSummary
+    });
+  }
+}
+async function readPageRecord(args) {
+  return readDbRecord({
+    dbKey: args.dbKey,
+    authToken: args.authToken,
+    fetchImpl: fetch,
+    serverUrl: args.serverUrl
+  });
+}
+function buildSkillSummaryForRecord(record) {
+  const meta = record?.meta;
+  const skillConfig = meta?.skillConfig;
+  if (!skillConfig) return void 0;
+  return buildSkillSummaryMarker(meta);
+}
+
+export {
+  readBodyArg,
+  createPageId,
+  buildPageKey,
+  buildPageRecord,
+  buildSkillDocId,
+  buildSkillPageKey,
+  buildSkillPageRecord,
+  parseJsonArg,
+  removePageFromSpace,
+  hasHelpArg,
+  hasFlag,
+  resolveWriteTargets,
+  readTitle,
+  resolveDocKind,
+  requireTokenUser,
+  writePageRecord,
+  readPageRecord,
+  buildSkillSummaryForRecord
+};

package/chunk-7U44LYTR.js

@@ -0,0 +1,238 @@
+import {
+  getRuntimeServerContext,
+  scheduleDeleteReplication
+} from "./chunk-UTLZINAP.js";
+import {
+  fetchFromClientDb
+} from "./chunk-OOSFSFMA.js";
+import {
+  buildTombstoneRecord
+} from "./chunk-GBRG75BQ.js";
+
+// packages/database/fileStorage.ts
+var DB_NAME = "nolo-file-storage";
+var STORE_NAME = "files";
+var DB_VERSION = 1;
+var dbPromise = null;
+var openFileDb = () => {
+  if (dbPromise) return dbPromise;
+  if (typeof indexedDB === "undefined") {
+    console.warn(
+      "[fileStorage] indexedDB is not available in this environment. File caching is disabled."
+    );
+    dbPromise = Promise.reject(
+      new Error("indexedDB is not available in this environment")
+    );
+    return dbPromise;
+  }
+  dbPromise = new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onerror = () => {
+      console.error("[fileStorage] Failed to open IndexedDB:", request.error);
+      reject(request.error);
+    };
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        const store = db.createObjectStore(STORE_NAME, {
+          keyPath: "id"
+        });
+        store.createIndex("createdAt", "createdAt", { unique: false });
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      db.onversionchange = () => {
+        db.close();
+        console.warn(
+          "[fileStorage] IndexedDB version change detected, closing old connection."
+        );
+      };
+      resolve(db);
+    };
+  });
+  return dbPromise;
+};
+var saveFileToIndexedDb = async (fileId, file) => {
+  try {
+    const db = await openFileDb();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const blob = file instanceof Blob ? file : new Blob([file]);
+    const record = {
+      id: fileId,
+      blob,
+      size: blob.size,
+      type: blob.type || "application/octet-stream",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const request = store.put(record);
+    await new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        console.debug(
+          "[fileStorage] Saved file to IndexedDB:",
+          fileId,
+          "size=",
+          record.size,
+          "type=",
+          record.type
+        );
+        resolve();
+      };
+      request.onerror = () => {
+        console.error(
+          "[fileStorage] Failed to save file to IndexedDB:",
+          fileId,
+          request.error
+        );
+        reject(request.error);
+      };
+    });
+    await new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error);
+    });
+  } catch (err) {
+    console.warn(
+      "[fileStorage] saveFileToIndexedDb error (non-fatal, caching disabled for this file):",
+      err
+    );
+  }
+};
+var loadFileFromIndexedDb = async (fileId) => {
+  try {
+    const db = await openFileDb();
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.get(fileId);
+    const record = await new Promise(
+      (resolve, reject) => {
+        request.onsuccess = () => {
+          const result = request.result;
+          if (result) {
+            console.debug(
+              "[fileStorage] Loaded file from IndexedDB:",
+              fileId,
+              "size=",
+              result.size,
+              "type=",
+              result.type
+            );
+          } else {
+            console.debug(
+              "[fileStorage] No local file found in IndexedDB for id:",
+              fileId
+            );
+          }
+          resolve(result ?? null);
+        };
+        request.onerror = () => {
+          console.error(
+            "[fileStorage] Failed to load file from IndexedDB:",
+            fileId,
+            request.error
+          );
+          reject(request.error);
+        };
+      }
+    );
+    return record ?? null;
+  } catch (err) {
+    console.warn(
+      "[fileStorage] loadFileFromIndexedDb error, treat as cache miss:",
+      err
+    );
+    return null;
+  }
+};
+var deleteFileFromIndexedDb = async (fileId) => {
+  try {
+    const db = await openFileDb();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    const store = tx.objectStore(STORE_NAME);
+    const request = store.delete(fileId);
+    await new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        console.debug("[fileStorage] Deleted file from IndexedDB:", fileId);
+        resolve();
+      };
+      request.onerror = () => {
+        console.error(
+          "[fileStorage] Failed to delete file from IndexedDB:",
+          fileId,
+          request.error
+        );
+        reject(request.error);
+      };
+    });
+    await new Promise((resolve, reject) => {
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+      tx.onabort = () => reject(tx.error);
+    });
+  } catch (err) {
+    console.warn("[fileStorage] deleteFileFromIndexedDb error:", err);
+  }
+};
+
+// packages/database/actions/remove.ts
+var removeAction = async (payload, thunkApi) => {
+  const { db: clientDb } = thunkApi.extra;
+  const dbKey = typeof payload === "string" ? payload : payload.dbKey;
+  const preferredServerOrigin = typeof payload === "string" ? void 0 : payload.preferredServerOrigin;
+  if (!clientDb) {
+    throw new Error("Client database is undefined in removeAction");
+  }
+  const state = thunkApi.getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state);
+  console.log("[removeAction] START", {
+    dbKey,
+    preferredServerOrigin,
+    currentServer,
+    syncServers,
+    hasToken: Boolean(state?.auth?.currentToken)
+  });
+  const localData = await fetchFromClientDb(clientDb, dbKey);
+  const hadLocalData = Boolean(localData);
+  console.log("[removeAction] replication inputs", {
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    hadLocalData
+  });
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  if (localData) {
+    if (localData.id && typeof localData.id === "string") {
+      void deleteFileFromIndexedDb(localData.id).catch((err) => {
+        console.warn("[removeAction] Failed to delete associated file:", localData.id, err);
+      });
+    }
+    await clientDb.put(dbKey, buildTombstoneRecord(localData, nowIso));
+  } else {
+    await clientDb.put(dbKey, buildTombstoneRecord({ dbKey }, nowIso));
+  }
+  scheduleDeleteReplication({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    state,
+    onResult: (result) => {
+      if (result.failed.length > 0) {
+        console.warn("[removeAction] Server delete failures after local tombstone:", result.failed);
+      }
+    },
+    onError: (err) => {
+      console.warn("[removeAction] Background server delete error:", err);
+    }
+  });
+  return { dbKey };
+};
+
+export {
+  saveFileToIndexedDb,
+  loadFileFromIndexedDb,
+  deleteFileFromIndexedDb,
+  removeAction
+};

package/chunk-AFON4QUU.js

@@ -0,0 +1,112 @@
+import {
+  buildSkillDiscoveryLayer
+} from "./chunk-C4FTUXVF.js";
+import {
+  load
+} from "./chunk-WZSRQNQG.js";
+
+// packages/agent-runtime/skillDiscovery.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+var SKILL_SCAN_DIRS = [".agents/skills", "docs/skills"];
+var MAX_DISCOVERED_SKILLS = 50;
+function parseSkillFrontmatter(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf8").slice(0, 2048);
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return {};
+    const fm = load(fmMatch[1]);
+    if (!fm || typeof fm !== "object") return {};
+    const name = typeof fm.name === "string" ? fm.name : void 0;
+    const rawDesc = fm.description;
+    const description = typeof rawDesc === "string" ? rawDesc : rawDesc == null ? void 0 : String(rawDesc);
+    const sanitize = (s) => s?.trim().replace(/^["']|["']$/g, "").replace(/[\n\r]+/g, " ").slice(0, 200);
+    return { name: sanitize(name), description: sanitize(description) };
+  } catch {
+    return {};
+  }
+}
+function discoverSkills(cwd) {
+  const skills = [];
+  for (const dir of SKILL_SCAN_DIRS) {
+    if (skills.length >= MAX_DISCOVERED_SKILLS) break;
+    const absDir = join(cwd, dir);
+    if (!existsSync(absDir) || !statSync(absDir).isDirectory()) continue;
+    try {
+      for (const entry of readdirSync(absDir)) {
+        if (skills.length >= MAX_DISCOVERED_SKILLS) break;
+        const skillMdPath = join(absDir, entry, "SKILL.md");
+        if (existsSync(skillMdPath)) {
+          const { name, description } = parseSkillFrontmatter(skillMdPath);
+          skills.push({ name: name ?? entry, description: description ?? "", relativePath: join(dir, entry, "SKILL.md") });
+          continue;
+        }
+        if (dir === "docs/skills" && entry.endsWith(".md")) {
+          const flatPath = join(absDir, entry);
+          const { name, description } = parseSkillFrontmatter(flatPath);
+          skills.push({ name: name ?? entry.replace(/\.md$/, ""), description: description ?? "", relativePath: join(dir, entry) });
+        }
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+function resolveSkillByName(cwd, name) {
+  const trimmed = name.trim();
+  if (!trimmed || trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("..")) {
+    return null;
+  }
+  const agentsDir = join(cwd, ".agents", "skills", trimmed);
+  const agentsSkillMd = join(agentsDir, "SKILL.md");
+  if (existsSync(agentsSkillMd)) return agentsSkillMd;
+  const agentsParent = join(cwd, ".agents", "skills");
+  if (existsSync(agentsParent) && statSync(agentsParent).isDirectory()) {
+    try {
+      for (const entry of readdirSync(agentsParent)) {
+        const candidate = join(agentsParent, entry, "SKILL.md");
+        if (!existsSync(candidate)) continue;
+        try {
+          const { name: fmName } = parseSkillFrontmatter(candidate);
+          if (fmName && fmName === trimmed) return candidate;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  const docsFlat = join(cwd, "docs", "skills", `${trimmed}.md`);
+  if (existsSync(docsFlat)) return docsFlat;
+  const docsDir = join(cwd, "docs", "skills");
+  if (existsSync(docsDir) && statSync(docsDir).isDirectory()) {
+    try {
+      for (const entry of readdirSync(docsDir)) {
+        if (!entry.endsWith(".md")) continue;
+        const candidate = join(docsDir, entry);
+        try {
+          const { name: fmName } = parseSkillFrontmatter(candidate);
+          if (fmName && fmName === trimmed) return candidate;
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function buildSkillDiscoveryContextBlock(cwd) {
+  try {
+    const discovered = discoverSkills(cwd);
+    const layer = buildSkillDiscoveryLayer(discovered, cwd);
+    return layer?.content ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  parseSkillFrontmatter,
+  discoverSkills,
+  resolveSkillByName,
+  buildSkillDiscoveryContextBlock
+};