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

package/chunk-U4TRT5V4.js

@@ -0,0 +1,246 @@
+import {
+  resolveNoloHome
+} from "./chunk-LM6IYQ3F.js";
+
+// packages/database-engine/cliAuthorityBrokerClient.ts
+import { createConnection } from "node:net";
+var DEFAULT_ITERATOR_PAGE_SIZE = 200;
+var CliAuthorityBrokerUnavailableError = class extends Error {
+  reason = "cli_authority_broker_unavailable";
+  status = 503;
+  endpoint;
+  constructor(endpoint, cause) {
+    super(`CLI authority broker unavailable at ${endpoint}. Start the local authority broker and retry.`);
+    this.name = "CliAuthorityBrokerUnavailableError";
+    this.endpoint = endpoint;
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+};
+var CliAuthorityBrokerProtocolError = class extends Error {
+  code;
+  retryable;
+  constructor(error) {
+    super(error.message);
+    this.name = "CliAuthorityBrokerProtocolError";
+    this.code = error.code;
+    this.retryable = error.retryable === true;
+  }
+};
+function isCliAuthorityBrokerUnavailableError(error) {
+  return error instanceof CliAuthorityBrokerUnavailableError || typeof error === "object" && error !== null && error.reason === "cli_authority_broker_unavailable" && error.status === 503;
+}
+function isCliAuthorityBrokerProtocolError(error) {
+  return error instanceof CliAuthorityBrokerProtocolError;
+}
+function resolveBrokerSocketTarget(endpoint) {
+  if (endpoint.startsWith("unix://")) {
+    return { kind: "unix", path: endpoint.slice("unix://".length) };
+  }
+  if (endpoint.startsWith("tcp://")) {
+    const url = new URL(endpoint);
+    return {
+      kind: "tcp",
+      host: url.hostname,
+      port: Number(url.port)
+    };
+  }
+  throw new Error(`Unsupported CLI authority broker endpoint: ${endpoint}`);
+}
+function createCliAuthorityBrokerSocketInvoker(options) {
+  const target = resolveBrokerSocketTarget(options.endpoint);
+  return async (request) => {
+    return await new Promise((resolve, reject) => {
+      const socket = target.kind === "unix" ? createConnection(target.path) : createConnection({ host: target.host, port: target.port });
+      let responseBuffer = "";
+      let settled = false;
+      const timeout = setTimeout(() => {
+        finish(() => {
+          socket.destroy();
+          reject(new Error(`CLI authority broker request at ${options.endpoint} timed out after 5000ms`));
+        });
+      }, 5e3);
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        fn();
+      };
+      socket.setEncoding("utf8");
+      socket.on("connect", () => {
+        socket.write(`${JSON.stringify(request)}
+`);
+      });
+      socket.on("data", (chunk) => {
+        responseBuffer += chunk;
+      });
+      socket.on("end", () => {
+        finish(() => {
+          const payload = responseBuffer.trim();
+          if (!payload) {
+            reject(new Error(`CLI authority broker at ${options.endpoint} returned no response`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(payload));
+          } catch (error) {
+            reject(error);
+          }
+        });
+      });
+      socket.on("error", (error) => {
+        finish(() => reject(error));
+      });
+    });
+  };
+}
+async function invokeBrokerRequest(options, request) {
+  try {
+    const response = await options.invoke(request);
+    if (response.ok) return response.result;
+    if (response.error.code === "BROKER_UNAVAILABLE") {
+      throw new CliAuthorityBrokerUnavailableError(options.endpoint, response.error);
+    }
+    throw new CliAuthorityBrokerProtocolError(response.error);
+  } catch (error) {
+    if (isCliAuthorityBrokerUnavailableError(error)) throw error;
+    if (isCliAuthorityBrokerProtocolError(error)) throw error;
+    throw new CliAuthorityBrokerUnavailableError(options.endpoint, error);
+  }
+}
+function createCliAuthorityBrokerClient(options) {
+  const pageSize = options.iteratorPageSize ?? DEFAULT_ITERATOR_PAGE_SIZE;
+  return {
+    get location() {
+      return options.location ?? options.endpoint;
+    },
+    get status() {
+      return options.status ?? "broker";
+    },
+    async open() {
+      await invokeBrokerRequest(options, { type: "status" });
+    },
+    async close() {
+    },
+    async get(key) {
+      const result = await invokeBrokerRequest(options, { type: "get", key });
+      if (result.type !== "get") {
+        throw new Error(`CLI authority broker protocol mismatch for get at ${options.endpoint}`);
+      }
+      return result.value;
+    },
+    async put(key, value) {
+      await invokeBrokerRequest(options, { type: "put", key, value });
+    },
+    async del(key) {
+      await invokeBrokerRequest(options, { type: "del", key });
+    },
+    async batchWrite(ops) {
+      await invokeBrokerRequest(options, { type: "batchWrite", ops });
+    },
+    createBatch() {
+      const ops = [];
+      return {
+        put(key, value) {
+          ops.push({ type: "put", key, value });
+        },
+        del(key) {
+          ops.push({ type: "del", key });
+        },
+        async write() {
+          await invokeBrokerRequest(options, { type: "batchWrite", ops });
+        }
+      };
+    },
+    iterator(iteratorOptions = {}) {
+      return async function* iterate() {
+        let cursor = void 0;
+        while (true) {
+          const result = await invokeBrokerRequest(options, {
+            type: "iterator",
+            options: iteratorOptions,
+            cursor,
+            limit: pageSize
+          });
+          if (result.type !== "iterator") {
+            throw new Error(
+              `CLI authority broker protocol mismatch for iterator at ${options.endpoint}`
+            );
+          }
+          for (const entry of result.page.entries) {
+            yield entry;
+          }
+          if (result.page.done || !result.page.nextCursor) return;
+          cursor = result.page.nextCursor;
+        }
+      }();
+    }
+  };
+}
+
+// packages/database-engine/cliAuthorityStoreDriver.ts
+import path from "node:path";
+function readCliAuthorityDriver(env) {
+  const value = env.NOLO_CLI_AUTHORITY_DRIVER?.trim();
+  if (value === "broker") {
+    return { driver: "broker", invalidDriver: null };
+  }
+  return {
+    driver: "broker",
+    invalidDriver: value ? value : null
+  };
+}
+function resolveCliAuthorityRunDir(options = {}) {
+  return path.join(resolveNoloHome({
+    ...options,
+    env: options.env ?? {}
+  }), "run");
+}
+function hashString(value) {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = (hash << 5) - hash + value.charCodeAt(index) | 0;
+  }
+  return Math.abs(hash);
+}
+function resolveCliAuthorityBrokerPort(options = {}) {
+  const envPort = options.env?.NOLO_CLI_AUTHORITY_BROKER_PORT?.trim();
+  if (envPort) {
+    const port = Number(envPort);
+    if (Number.isInteger(port) && port > 0 && port < 65536) return port;
+  }
+  const noloHome = resolveNoloHome({
+    ...options,
+    env: options.env ?? {}
+  });
+  return 47e3 + hashString(noloHome) % 2e3;
+}
+function resolveCliAuthorityStoreDriver(options = {}) {
+  return readCliAuthorityDriver(options.env ?? {}).driver;
+}
+function resolveCliAuthorityBrokerSocketPath(options) {
+  return path.join(resolveCliAuthorityRunDir(options), "authority-store-broker.sock");
+}
+function resolveCliAuthorityBrokerEndpoint(options) {
+  if (options.transport === "tcp") {
+    return `tcp://127.0.0.1:${resolveCliAuthorityBrokerPort(options)}`;
+  }
+  return `unix://${resolveCliAuthorityBrokerSocketPath(options)}`;
+}
+function resolveCliAuthorityBrokerMetadataPath(options) {
+  return path.join(resolveCliAuthorityRunDir(options), "authority-store-broker.json");
+}
+function resolveCliAuthorityBrokerHealthPath(options) {
+  return path.join(resolveCliAuthorityRunDir(options), "authority-store-broker.health.json");
+}
+
+export {
+  isCliAuthorityBrokerUnavailableError,
+  createCliAuthorityBrokerSocketInvoker,
+  createCliAuthorityBrokerClient,
+  resolveCliAuthorityStoreDriver,
+  resolveCliAuthorityBrokerEndpoint,
+  resolveCliAuthorityBrokerMetadataPath,
+  resolveCliAuthorityBrokerHealthPath
+};

package/chunk-U6VC4MU4.js

@@ -0,0 +1,8 @@
+// packages/core/optionalPositiveNumber.ts
+function asOptionalPositiveFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+
+export {
+  asOptionalPositiveFiniteNumber
+};

package/chunk-UAD2WT54.js

@@ -0,0 +1,64 @@
+// packages/create/space/spaceKeys.ts
+var SEPARATOR = "-";
+var SPACE_PREFIX = "space";
+var SPACE_PREFIX_WITH_SEPARATOR = `${SPACE_PREFIX}${SEPARATOR}`;
+var normalizeSpaceId = (spaceId) => {
+  if (!spaceId) return spaceId;
+  return spaceId.startsWith(SPACE_PREFIX_WITH_SEPARATOR) ? spaceId.slice(SPACE_PREFIX_WITH_SEPARATOR.length) : spaceId;
+};
+var createSpaceKey = {
+  // 空间基础信息的key
+  space: (spaceId) => {
+    return [SPACE_PREFIX, normalizeSpaceId(spaceId)].join(SEPARATOR);
+  },
+  // 空间成员的key
+  member: (userId, spaceId) => {
+    return [SPACE_PREFIX, "member", userId, normalizeSpaceId(spaceId)].join(
+      SEPARATOR
+    );
+  },
+  // 查询用户所在的所有空间的范围
+  memberRange: (userId) => {
+    return {
+      start: [SPACE_PREFIX, "member", userId, ""].join(SEPARATOR),
+      end: [SPACE_PREFIX, "member", userId, "\uFFFF"].join(SEPARATOR)
+    };
+  },
+  /**
+   * 预留：未来若出现“按用户、按空间、且必须跨设备同步”的空间级偏好，
+   * 统一使用这个 key family。当前产品主链不要依赖它。
+   */
+  setting: (userId, spaceId) => {
+    return [SPACE_PREFIX, "setting", userId, normalizeSpaceId(spaceId)].join(
+      SEPARATOR
+    );
+  },
+  /**
+   * 预留：未来如确实需要批量读取空间级远端偏好，再使用这个范围。
+   */
+  settingRange: (userId) => {
+    return {
+      start: [SPACE_PREFIX, "setting", userId, ""].join(SEPARATOR),
+      end: [SPACE_PREFIX, "setting", userId, "\uFFFF"].join(SEPARATOR)
+    };
+  },
+  // 从成员key中提取空间key
+  // 成员 key 格式: space-member-{userId}-{spaceId}
+  // userId 是单段（无连字符），spaceId 是 ULID（无连字符）
+  spaceFromMember: (memberKey) => {
+    const parts = memberKey.split(SEPARATOR);
+    if (parts.length < 4) return "";
+    const spaceId = parts[parts.length - 1];
+    return [SPACE_PREFIX, spaceId].join(SEPARATOR);
+  },
+  // 从成员key中提取空间ID
+  spaceIdFromMember: (memberKey) => {
+    const parts = memberKey.split(SEPARATOR);
+    return parts.length >= 4 ? parts[parts.length - 1] : "";
+  }
+};
+
+export {
+  normalizeSpaceId,
+  createSpaceKey
+};

package/chunk-VC6OZXO5.js

@@ -0,0 +1,298 @@
+import {
+  dump,
+  load
+} from "./chunk-WZSRQNQG.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/ai/skills/skillDocProtocol.ts
+var SKILL_DOC_ENUMS = {
+  triggerMode: ["explicit", "required", "recommended"],
+  budgetTier: ["low", "medium", "high"],
+  modality: ["text", "image", "video", "audio", "3d"],
+  docKind: ["knowledge", "instruction", "skill"]
+};
+var SKILL_CONFIG_BLOCK = "skill-config";
+var EVAL_CONFIG_BLOCK = "eval-config";
+var WORKFLOW_CONFIG_BLOCK = "workflow-config";
+var normalizeStringArray = (value) => {
+  if (!Array.isArray(value)) return void 0;
+  const items = [...new Set(asTrimmedNonEmptyStringArray(value))];
+  return items.length > 0 ? items : void 0;
+};
+var normalizeBoolean = (value) => typeof value === "boolean" ? value : void 0;
+var normalizeSkillEnumValue = (key, value) => typeof value === "string" && SKILL_DOC_ENUMS[key].includes(value) ? value : void 0;
+var normalizeSkillBudgetTier = (value) => normalizeSkillEnumValue("budgetTier", value);
+var normalizeSkillModalities = (value) => {
+  const raw = normalizeStringArray(value);
+  if (!raw) return void 0;
+  const filtered = raw.flatMap((item) => {
+    const modality = normalizeSkillEnumValue("modality", item);
+    return modality ? [modality] : [];
+  });
+  return filtered.length > 0 ? Array.from(new Set(filtered)) : void 0;
+};
+var normalizeSkillConfig = (value, fallbackTools) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const name = asOptionalTrimmedString(record.name) ?? "";
+  const description = asOptionalTrimmedString(record.description) ?? "";
+  if (!name || !description) return void 0;
+  const triggerMode = normalizeSkillEnumValue("triggerMode", record.triggerMode);
+  const budgetTier = normalizeSkillEnumValue("budgetTier", record.budgetTier);
+  const modalities = normalizeSkillModalities(record.modalities);
+  const toolNames = normalizeStringArray(record.toolNames) ?? normalizeStringArray(fallbackTools) ?? void 0;
+  const discover = record.discover && typeof record.discover === "object" ? {
+    keywords: normalizeStringArray(
+      record.discover.keywords
+    ),
+    examples: normalizeStringArray(
+      record.discover.examples
+    )
+  } : void 0;
+  return {
+    version: "0.1",
+    kind: "skill",
+    id: asOptionalTrimmedString(record.id),
+    name,
+    description,
+    triggerMode,
+    toolNames,
+    preferredAgents: normalizeStringArray(record.preferredAgents),
+    budgetTier,
+    dispatchPreferred: normalizeBoolean(record.dispatchPreferred),
+    modalities,
+    requiredSkills: normalizeStringArray(record.requiredSkills),
+    recommendedSkills: normalizeStringArray(record.recommendedSkills),
+    promptPatch: asOptionalTrimmedString(record.promptPatch),
+    discover: discover?.keywords || discover?.examples ? discover : void 0
+  };
+};
+var normalizeEvalConfig = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  if (!Array.isArray(record.cases)) return void 0;
+  const cases = [];
+  for (const item of record.cases) {
+    if (!item || typeof item !== "object") continue;
+    const testCase = item;
+    const input = asOptionalTrimmedString(testCase.input) ?? "";
+    if (!input) continue;
+    cases.push({
+      input,
+      expectedTools: normalizeStringArray(testCase.expectedTools),
+      expectedSignals: normalizeStringArray(testCase.expectedSignals),
+      forbiddenSignals: normalizeStringArray(testCase.forbiddenSignals)
+    });
+  }
+  return cases.length > 0 ? {
+    version: "0.1",
+    cases
+  } : void 0;
+};
+var normalizeWorkflowConfig = (value) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const name = asOptionalTrimmedString(record.name) ?? "";
+  const description = asOptionalTrimmedString(record.description) ?? "";
+  if (!name || !description) return void 0;
+  const budgetTier = normalizeSkillEnumValue("budgetTier", record.budgetTier);
+  return {
+    version: "0.1",
+    kind: "workflow",
+    id: asOptionalTrimmedString(record.id),
+    name,
+    description,
+    defaultAgent: asOptionalTrimmedString(record.defaultAgent),
+    inputs: normalizeStringArray(record.inputs),
+    recommendedTools: normalizeStringArray(record.recommendedTools),
+    requiredTools: normalizeStringArray(record.requiredTools),
+    requiredOutputs: normalizeStringArray(record.requiredOutputs),
+    gates: normalizeStringArray(record.gates),
+    budgetTier,
+    contextStrategy: asOptionalTrimmedString(record.contextStrategy),
+    failureProtocol: asOptionalTrimmedString(record.failureProtocol)
+  };
+};
+var normalizePageSkillMetadata = (value, fallbackTools) => {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const kind = normalizeSkillEnumValue("docKind", record.kind);
+  const meta = {
+    kind,
+    requiredSkills: normalizeStringArray(record.requiredSkills),
+    recommendedSkills: normalizeStringArray(record.recommendedSkills),
+    skillConfig: normalizeSkillConfig(record.skillConfig, fallbackTools),
+    evalConfig: normalizeEvalConfig(record.evalConfig),
+    workflowConfig: normalizeWorkflowConfig(record.workflowConfig)
+  };
+  if (meta.skillConfig && !meta.kind) {
+    meta.kind = "skill";
+  }
+  if (meta.workflowConfig && !meta.kind) {
+    meta.kind = "instruction";
+  }
+  return meta.kind || meta.requiredSkills || meta.recommendedSkills || meta.skillConfig || meta.evalConfig || meta.workflowConfig ? meta : void 0;
+};
+var extractCommentBlock = (markdown, blockName) => {
+  if (!markdown) return void 0;
+  const matcher = new RegExp(
+    `<!--\\s*${blockName}\\s*\\n([\\s\\S]*?)-->`,
+    "i"
+  );
+  const match = markdown.match(matcher);
+  return asOptionalTrimmedString(match?.[1]);
+};
+var removeCommentBlock = (markdown, blockName) => markdown.replace(
+  new RegExp(`\\n?<!--\\s*${blockName}\\s*\\n[\\s\\S]*?-->\\s*`, "gi"),
+  "\n\n"
+);
+var parseYamlObject = (raw) => {
+  if (!raw) return void 0;
+  try {
+    const parsed = load(raw);
+    return parsed && typeof parsed === "object" ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var parseSkillDocProtocol = (markdown, existingMeta, fallbackTools) => {
+  const source = typeof markdown === "string" ? markdown : "";
+  const skillBlock = parseYamlObject(extractCommentBlock(source, SKILL_CONFIG_BLOCK));
+  const evalBlock = parseYamlObject(extractCommentBlock(source, EVAL_CONFIG_BLOCK));
+  const workflowBlock = parseYamlObject(extractCommentBlock(source, WORKFLOW_CONFIG_BLOCK));
+  const cleanedContent = removeCommentBlock(
+    removeCommentBlock(
+      removeCommentBlock(source, SKILL_CONFIG_BLOCK),
+      EVAL_CONFIG_BLOCK
+    ),
+    WORKFLOW_CONFIG_BLOCK
+  ).replace(/\n{3,}/g, "\n\n").trim();
+  const parsedMeta = normalizePageSkillMetadata(
+    {
+      ...existingMeta ?? {},
+      ...skillBlock ? {
+        kind: existingMeta?.kind === "skill" || skillBlock.kind === "skill" ? "skill" : existingMeta?.kind,
+        requiredSkills: skillBlock.requiredSkills ?? existingMeta?.requiredSkills,
+        recommendedSkills: skillBlock.recommendedSkills ?? existingMeta?.recommendedSkills,
+        skillConfig: skillBlock
+      } : {},
+      ...evalBlock ? { evalConfig: evalBlock } : {},
+      ...workflowBlock ? { workflowConfig: workflowBlock } : {}
+    },
+    fallbackTools
+  );
+  return {
+    content: cleanedContent,
+    meta: parsedMeta
+  };
+};
+var resolvePageSkillMetadata = (page) => {
+  if (!page) return void 0;
+  const existingMeta = normalizePageSkillMetadata(page.meta, page.tools);
+  return parseSkillDocProtocol(page.content ?? "", existingMeta, page.tools).meta;
+};
+var yamlBlock = (value) => dump(value, { lineWidth: 120, noRefs: true }).trim();
+var buildSkillConfigComment = (config) => {
+  const payload = {
+    version: config.version,
+    kind: config.kind,
+    ...config.id ? { id: config.id } : {},
+    name: config.name,
+    description: config.description,
+    ...config.triggerMode ? { triggerMode: config.triggerMode } : {},
+    ...config.requiredSkills?.length ? { requiredSkills: config.requiredSkills } : {},
+    ...config.recommendedSkills?.length ? { recommendedSkills: config.recommendedSkills } : {},
+    ...config.toolNames?.length ? { toolNames: config.toolNames } : {},
+    ...config.preferredAgents?.length ? { preferredAgents: config.preferredAgents } : {},
+    ...config.budgetTier ? { budgetTier: config.budgetTier } : {},
+    ...typeof config.dispatchPreferred === "boolean" ? { dispatchPreferred: config.dispatchPreferred } : {},
+    ...config.modalities?.length ? { modalities: config.modalities } : {},
+    ...config.discover?.keywords?.length || config.discover?.examples?.length ? {
+      discover: {
+        ...config.discover?.keywords?.length ? { keywords: config.discover.keywords } : {},
+        ...config.discover?.examples?.length ? { examples: config.discover.examples } : {}
+      }
+    } : {},
+    ...config.promptPatch ? { promptPatch: config.promptPatch } : {}
+  };
+  return `<!-- ${SKILL_CONFIG_BLOCK}
+${yamlBlock(payload)}
+-->`;
+};
+var buildEvalConfigComment = (config) => `<!-- ${EVAL_CONFIG_BLOCK}
+${yamlBlock({
+  version: config.version,
+  cases: config.cases
+})}
+-->`;
+var buildWorkflowConfigComment = (config) => `<!-- ${WORKFLOW_CONFIG_BLOCK}
+${yamlBlock({
+  version: config.version,
+  kind: config.kind,
+  ...config.id ? { id: config.id } : {},
+  name: config.name,
+  description: config.description,
+  ...config.defaultAgent ? { defaultAgent: config.defaultAgent } : {},
+  ...config.inputs?.length ? { inputs: config.inputs } : {},
+  ...config.recommendedTools?.length ? { recommendedTools: config.recommendedTools } : {},
+  ...config.requiredTools?.length ? { requiredTools: config.requiredTools } : {},
+  ...config.requiredOutputs?.length ? { requiredOutputs: config.requiredOutputs } : {},
+  ...config.gates?.length ? { gates: config.gates } : {},
+  ...config.budgetTier ? { budgetTier: config.budgetTier } : {},
+  ...config.contextStrategy ? { contextStrategy: config.contextStrategy } : {},
+  ...config.failureProtocol ? { failureProtocol: config.failureProtocol } : {}
+})}
+-->`;
+var buildSkillDocMarkdown = (options) => {
+  const sections = [
+    asOptionalTrimmedString(options.body) ?? "",
+    buildSkillConfigComment(options.skillConfig),
+    options.evalConfig ? buildEvalConfigComment(options.evalConfig) : "",
+    options.workflowConfig ? buildWorkflowConfigComment(options.workflowConfig) : ""
+  ].filter(Boolean);
+  return sections.join("\n\n").trim();
+};
+var extractFrontmatter = (markdown) => {
+  const match = markdown.match(/^\s*---\s*\n([\s\S]*?)\n\s*---\s*\n?/);
+  if (!match) return { body: markdown.trim() };
+  const frontmatter = parseYamlObject(match[1]);
+  const body = markdown.slice(match[0].length).trim();
+  return { frontmatter, body };
+};
+var normalizeAllowedTools = (value) => {
+  if (Array.isArray(value)) {
+    return normalizeStringArray(value) ?? [];
+  }
+  if (typeof value === "string") {
+    return value.split(/\s+/).map((item) => item.trim()).filter(Boolean);
+  }
+  return [];
+};
+var parseExternalSkillMarkdown = (markdown) => {
+  const { frontmatter, body } = extractFrontmatter(markdown);
+  return {
+    name: asOptionalTrimmedString(frontmatter?.name),
+    description: asOptionalTrimmedString(frontmatter?.description),
+    compatibility: asOptionalTrimmedString(frontmatter?.compatibility),
+    allowedTools: normalizeAllowedTools(frontmatter?.["allowed-tools"]),
+    metadata: frontmatter?.metadata && typeof frontmatter.metadata === "object" ? Object.fromEntries(
+      Object.entries(frontmatter.metadata).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, String(value)])
+    ) : void 0,
+    body
+  };
+};
+
+export {
+  normalizeStringArray,
+  normalizeSkillBudgetTier,
+  normalizeSkillModalities,
+  parseSkillDocProtocol,
+  resolvePageSkillMetadata,
+  buildSkillDocMarkdown,
+  parseExternalSkillMarkdown
+};

package/chunk-VF4K2QE6.js

@@ -0,0 +1,21 @@
+// packages/ai/skills/skillSummaryMarker.ts
+var buildSkillSummaryMarker = (meta) => {
+  const skillConfig = meta?.skillConfig;
+  if (meta?.kind !== "skill" && !skillConfig) {
+    return null;
+  }
+  return {
+    isSkill: true,
+    ...skillConfig?.id ? { skillId: skillConfig.id } : {},
+    ...skillConfig?.name ? { name: skillConfig.name } : {},
+    ...skillConfig?.description ? { description: skillConfig.description } : {},
+    ...skillConfig?.toolNames?.length ? { toolNames: skillConfig.toolNames } : {},
+    ...skillConfig?.triggerMode ? { triggerMode: skillConfig.triggerMode } : {}
+  };
+};
+var isSkillSummaryMarker = (value) => Boolean(value?.isSkill);
+
+export {
+  buildSkillSummaryMarker,
+  isSkillSummaryMarker
+};

package/chunk-VHBWHNVT.js

@@ -0,0 +1,59 @@
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+
+// packages/cli/agentAliases.ts
+var CURRENT_OPERATOR_USER_ID = "0e95801d90";
+var NOLO_DEFAULT_AGENT_ID = "01NOLOAPPBLD000000019KCKT0";
+var NOLO_DEFAULT_AGENT_KEY = `agent-pub-${NOLO_DEFAULT_AGENT_ID}`;
+var NOLO_PROJECT_MANAGER_AGENT_ID = "01NOLOPROJMGR00000000MSVGG";
+var NOLO_PROJECT_MANAGER_AGENT_KEY = `agent-${CURRENT_OPERATOR_USER_ID}-${NOLO_PROJECT_MANAGER_AGENT_ID}`;
+var NOLO_FRONTEND_AGENT_ID = "01FRONTENDAG0000000115N4E1";
+var NOLO_FRONTEND_AGENT_KEY = `agent-${CURRENT_OPERATOR_USER_ID}-${NOLO_FRONTEND_AGENT_ID}`;
+var LOCAL_CODEX_AGENT_ID = "01LOCALCODEXCLI000000NEW";
+var LOCAL_CODEX_AGENT_KEY = `agent-${CURRENT_OPERATOR_USER_ID}-${LOCAL_CODEX_AGENT_ID}`;
+var AGENT_ALIAS_TO_KEY = {
+  nolo: NOLO_DEFAULT_AGENT_KEY,
+  default: NOLO_DEFAULT_AGENT_KEY,
+  "default-nolo": NOLO_DEFAULT_AGENT_KEY,
+  // Product implementation & coordination aliases
+  "frontend-implementer": NOLO_FRONTEND_AGENT_KEY,
+  "frontend-agent": NOLO_FRONTEND_AGENT_KEY,
+  frontend: NOLO_FRONTEND_AGENT_KEY,
+  "frontend agent": NOLO_FRONTEND_AGENT_KEY,
+  "\u524D\u7AEFagent": NOLO_FRONTEND_AGENT_KEY,
+  "\u524D\u7AEF agent": NOLO_FRONTEND_AGENT_KEY,
+  "project-manager": NOLO_PROJECT_MANAGER_AGENT_KEY,
+  pm: NOLO_PROJECT_MANAGER_AGENT_KEY,
+  // Explicit local CLI agents. These are ordinary private agent records that
+  // run through the current computer local runtime when unbound.
+  "local-codex": LOCAL_CODEX_AGENT_KEY,
+  "codex-local": LOCAL_CODEX_AGENT_KEY,
+  "local codex": LOCAL_CODEX_AGENT_KEY,
+  "minimax-m3": "agent-0e95801d90-minimax-m3",
+  minimax: "agent-0e95801d90-minimax-m3"
+};
+function parseAgentKeyFromInput(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    const url = new URL(trimmed);
+    return url.pathname.replace(/^\/+/, "");
+  }
+  return trimmed;
+}
+function resolveCliAgentKeyInput(raw) {
+  return AGENT_ALIAS_TO_KEY[asTrimmedLowercaseString(raw)] ?? parseAgentKeyFromInput(raw);
+}
+function isLocalCliAgentKey(agentKey) {
+  return agentKey === LOCAL_CODEX_AGENT_KEY;
+}
+
+export {
+  NOLO_DEFAULT_AGENT_ID,
+  NOLO_DEFAULT_AGENT_KEY,
+  NOLO_PROJECT_MANAGER_AGENT_KEY,
+  LOCAL_CODEX_AGENT_ID,
+  LOCAL_CODEX_AGENT_KEY,
+  resolveCliAgentKeyInput,
+  isLocalCliAgentKey
+};