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

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-7T5PWAZN.js

@@ -0,0 +1,171 @@
+import {
+  i18n_default,
+  toolRegistry
+} from "./chunk-ZDRZMLKO.js";
+import {
+  canonicalizeToolNames
+} from "./chunk-P3PKED2I.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/ai/tools/toolSchemaCompatibility.ts
+var COMPOSITION_KEYS = ["anyOf", "oneOf", "allOf"];
+var LIMITED_JSON_SCHEMA_PROVIDERS = /* @__PURE__ */ new Set([
+  "fireworks"
+]);
+var sanitizeSchemaNode = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeSchemaNode(item));
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const next = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (COMPOSITION_KEYS.includes(key)) {
+      continue;
+    }
+    next[key] = sanitizeSchemaNode(child);
+  }
+  return next;
+};
+var shouldSanitizeProviderSchema = (provider) => LIMITED_JSON_SCHEMA_PROVIDERS.has(asTrimmedLowercaseString(provider));
+var sanitizeToolForProvider = (tool, provider) => {
+  if (!shouldSanitizeProviderSchema(provider)) {
+    return tool;
+  }
+  const parameters = tool?.function?.parameters;
+  if (!isRecord(parameters)) {
+    return tool;
+  }
+  return {
+    ...tool,
+    function: {
+      ...tool.function,
+      parameters: sanitizeSchemaNode(parameters)
+    }
+  };
+};
+
+// packages/ai/tools/prepareTools.ts
+var translatedFunctionCache = /* @__PURE__ */ new Map();
+var prepareToolsResultCache = /* @__PURE__ */ new Map();
+var PREPARE_TOOLS_CACHE_LIMIT = 128;
+function getTranslation(keys, defaultVal) {
+  for (const key of keys) {
+    if (i18n_default.exists(key)) {
+      return i18n_default.t(key);
+    }
+    const aiKey = key.startsWith("ai:") ? key : `ai:${key}`;
+    if (i18n_default.exists(aiKey)) {
+      return i18n_default.t(aiKey);
+    }
+  }
+  return defaultVal;
+}
+function translateSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const nextSchema = JSON.parse(JSON.stringify(schema));
+  const toolName = nextSchema.name;
+  if (!toolName) return nextSchema;
+  const walk = (node, path) => {
+    if (!node || typeof node !== "object") return;
+    if (typeof node.description === "string") {
+      const keysToTry = [
+        `${path}.description`,
+        `${path}.desc`,
+        path,
+        node.description
+      ];
+      node.description = getTranslation(keysToTry, node.description);
+    }
+    if (node.parameters && typeof node.parameters === "object") {
+      walk(node.parameters, path);
+    }
+    if (node.properties && typeof node.properties === "object") {
+      for (const [key, child] of Object.entries(node.properties)) {
+        const nextPath = path.endsWith(".params") ? `${path}.${key}` : `${path}.params.${key}`;
+        walk(child, nextPath);
+      }
+    }
+    if (node.items && typeof node.items === "object") {
+      walk(node.items, path);
+    }
+    const compositions = ["anyOf", "oneOf", "allOf"];
+    for (const comp of compositions) {
+      if (Array.isArray(node[comp])) {
+        node[comp].forEach((child, idx) => {
+          const suffix = child.type === "string" ? "stringDesc" : child.type === "object" ? "objectDesc" : `${idx}`;
+          walk(child, `${path}.${suffix}`);
+        });
+      }
+    }
+  };
+  walk(nextSchema, `tools.${toolName}`);
+  return nextSchema;
+}
+function currentI18nLanguage() {
+  return typeof i18n_default.language === "string" ? i18n_default.language : "";
+}
+function translateSchemaCached(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const toolName = typeof schema.name === "string" ? schema.name : "";
+  if (!toolName) return translateSchema(schema);
+  const cacheKey = `${currentI18nLanguage()}\0${toolName}`;
+  const hit = translatedFunctionCache.get(cacheKey);
+  if (hit) return hit;
+  const translated = translateSchema(schema);
+  translatedFunctionCache.set(cacheKey, translated);
+  return translated;
+}
+function buildPrepareToolsCacheKey(toolNames, disabledToolNames, provider) {
+  return [
+    currentI18nLanguage(),
+    provider ?? "",
+    disabledToolNames.join(""),
+    toolNames.join("")
+  ].join("\0");
+}
+function rememberPrepareToolsResult(key, value) {
+  if (prepareToolsResultCache.size >= PREPARE_TOOLS_CACHE_LIMIT) {
+    const oldest = prepareToolsResultCache.keys().next().value;
+    if (oldest !== void 0) {
+      prepareToolsResultCache.delete(oldest);
+    }
+  }
+  prepareToolsResultCache.set(key, value);
+}
+var prepareTools = (toolNames, options) => {
+  const disabledList = canonicalizeToolNames(options?.disabledToolNames ?? []);
+  const disabledToolNames = new Set(disabledList);
+  const canonicalNames = canonicalizeToolNames(toolNames).filter(
+    (toolName) => !disabledToolNames.has(toolName)
+  );
+  const cacheKey = buildPrepareToolsCacheKey(
+    canonicalNames,
+    disabledList,
+    options?.provider
+  );
+  const cached = prepareToolsResultCache.get(cacheKey);
+  if (cached) {
+    return cached.slice();
+  }
+  const prepared = canonicalNames.map((toolName) => {
+    const regTool = toolRegistry[toolName];
+    if (!regTool) return regTool;
+    return {
+      ...regTool,
+      function: translateSchemaCached(regTool.function)
+    };
+  }).map((tool) => sanitizeToolForProvider(tool, options?.provider)).filter(Boolean);
+  rememberPrepareToolsResult(cacheKey, prepared);
+  return prepared.slice();
+};
+
+export {
+  prepareTools
+};

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
+};