nolo-cli 0.1.40 → 0.1.42

package/docCreateCommands.ts

@@ -0,0 +1,345 @@
+import { NOLO_CLUSTER_SERVERS } from "./database/config";
+import { DEFAULT_LOCAL_API_ORIGIN } from "./core/localOrigins";
+import { buildSkillSummaryMarker } from "./ai/skills/skillSummaryMarker";
+import { writeAgentRecord } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import {
+  buildPageKey,
+  buildPageRecord,
+  createPageId,
+  readBodyArg,
+} from "./docPageHelpers";
+import {
+  buildSkillDocId,
+  buildSkillPageKey,
+  buildSkillPageRecord,
+  parseJsonArg,
+} from "./docSkillHelpers";
+import { ensurePageAttachedToSpace } from "./docSpaceHelpers";
+import { findPotentialSecrets, formatSecretFindings } from "./secretScan";
+
+type DocKind = "page" | "skill";
+
+type DocCreateDeps = {
+  env: NodeJS.ProcessEnv;
+};
+
+const VALUE_FLAGS = new Set([
+  "--title",
+  "--description",
+  "--body",
+  "--body-file",
+  "--id",
+  "--space",
+  "--sync",
+  "--server",
+  "--server-url",
+  "--token",
+  "--tools",
+  "--required-skills",
+  "--recommended-skills",
+  "--preferred-agents",
+  "--trigger-mode",
+  "--budget-tier",
+  "--prompt-patch",
+  "--kind",
+]);
+
+function hasHelpArg(args: string[]) {
+  return args.includes("--help") || args.includes("-h");
+}
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function printDocCreateUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo doc create --title <title> [--body ... | --body-file path] [--id ...] [--space ...]
+
+Options:
+  --description <text>      Optional page description stored in meta.
+  --sync local,main,us      Choose write targets. Values may also be full URLs.
+  --local-only              Write only to the local server target.
+  --no-local                Exclude local targets when --sync includes them.
+  --dry-run                 Build and validate without writing.
+  --json                    Print machine-readable JSON.
+  --allow-secrets           Allow bodies that look like credentials.
+  --server <url>            Default write target when --sync is omitted.
+  --token <jwt>             Auth token. Required for writes.
+`);
+}
+
+function printSkillDocCreateUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo skill-doc create --title <title> --description <text> [--body ... | --body-file path]
+  nolo skill create-doc --title <title> --description <text> [--body ... | --body-file path]
+
+Options:
+  --tools '["readDoc"]'                 Tool names this skill expects.
+  --required-skills '["skill-a"]'       Required skill references.
+  --recommended-skills '["skill-b"]'    Recommended skill references.
+  --preferred-agents '["agent-key"]'    Preferred agent keys.
+  --trigger-mode explicit|required|recommended
+  --budget-tier low|medium|high
+  --prompt-patch <text>
+  --page | --kind page                  Create a normal page instead of a skill-backed page.
+  --sync local,main,us                  Choose write targets. Values may also be full URLs.
+  --dry-run                             Build and validate without writing.
+  --json                                Print machine-readable JSON.
+  --token <jwt>                         Auth token. Required for writes.
+`);
+}
+
+function normalizeBaseUrl(base: string) {
+  return base.trim().replace(/\/+$/, "");
+}
+
+function localBaseFromEnv(env: NodeJS.ProcessEnv) {
+  return normalizeBaseUrl(env.SCRIPT_LOCAL_BASE_URL || DEFAULT_LOCAL_API_ORIGIN);
+}
+
+function targetToBase(target: string, env: NodeJS.ProcessEnv) {
+  const normalized = target.trim().toLowerCase();
+  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: string | undefined, env: NodeJS.ProcessEnv) {
+  if (!raw) return undefined;
+  return raw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .filter((value) => value !== "none")
+    .map((value) => targetToBase(value, env));
+}
+
+function isLocalBaseUrl(baseUrl: string) {
+  try {
+    const hostname = new URL(baseUrl).hostname;
+    return hostname === "localhost" || hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+
+function resolveWriteTargets(args: string[], env: NodeJS.ProcessEnv) {
+  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: string[]) {
+  return readOption(args, "--title") ?? args.find((value, index) => {
+    if (index === 0) return false;
+    if (VALUE_FLAGS.has(args[index - 1])) return false;
+    return !value.startsWith("-");
+  });
+}
+
+function resolveDocKind(args: string[], fallback: DocKind): DocKind {
+  if (hasFlag(args, "--page") || readOption(args, "--kind") === "page") return "page";
+  return fallback;
+}
+
+function requireTokenUser(args: string[], env: NodeJS.ProcessEnv, dryRun: boolean) {
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken) || env.USER_ID || "";
+  if (!authToken && !dryRun) {
+    throw new Error("doc create 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: {
+  authToken: string;
+  dbKey: string;
+  record: Record<string, any>;
+  serverUrl: string;
+  spaceId: string | null;
+  title: string;
+  userId: string;
+  skillSummary?: Record<string, any> | null;
+}) {
+  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 runCreateCommand(
+  args: string[],
+  deps: DocCreateDeps,
+  options: { defaultKind: DocKind; usage: (output: { write(chunk: string): unknown }) => void }
+) {
+  if (hasHelpArg(args)) {
+    options.usage(process.stdout);
+    return 0;
+  }
+
+  const title = readTitle(args);
+  const description = readOption(args, "--description") ?? "";
+  const docKind = resolveDocKind(args, options.defaultKind);
+  const shouldDryRun = hasFlag(args, "--dry-run");
+  const shouldOutputJson = hasFlag(args, "--json");
+  const allowSecrets = hasFlag(args, "--allow-secrets");
+  const spaceId = readOption(args, "--space") ?? null;
+
+  if (!title || (docKind === "skill" && !description)) {
+    options.usage(process.stderr);
+    return 1;
+  }
+
+  const body = readBodyArg(args, "");
+  const secretFindings = findPotentialSecrets(body);
+  if (secretFindings.length && !allowSecrets) {
+    throw new Error(
+      [
+        "Document body appears to contain credentials or secrets. Pass --allow-secrets to write it anyway.",
+        formatSecretFindings(secretFindings),
+      ].join("\n")
+    );
+  }
+
+  const { authToken, userId } = requireTokenUser(args, deps.env, shouldDryRun);
+  const targets = resolveWriteTargets(args, deps.env);
+  if (!targets.length) {
+    throw new Error("No write targets resolved. Check --sync / --local-only / --no-local.");
+  }
+
+  const explicitId = readOption(args, "--id");
+  const docId = explicitId ?? (docKind === "skill" ? buildSkillDocId(title) : createPageId());
+  const dbKey = docKind === "skill" ? buildSkillPageKey(userId, docId) : buildPageKey(userId, docId);
+  const record =
+    docKind === "skill"
+      ? buildSkillPageRecord({
+          dbKey,
+          skillId: docId,
+          title,
+          spaceId,
+          body,
+          skillConfig: {
+            version: "0.1",
+            kind: "skill",
+            id: docId,
+            name: title,
+            description,
+            ...(parseJsonArg<string[]>(readOption(args, "--tools"), []).length
+              ? { toolNames: parseJsonArg<string[]>(readOption(args, "--tools"), []) }
+              : {}),
+            ...(parseJsonArg<string[]>(readOption(args, "--required-skills"), []).length
+              ? { requiredSkills: parseJsonArg<string[]>(readOption(args, "--required-skills"), []) }
+              : {}),
+            ...(parseJsonArg<string[]>(readOption(args, "--recommended-skills"), []).length
+              ? { recommendedSkills: parseJsonArg<string[]>(readOption(args, "--recommended-skills"), []) }
+              : {}),
+            ...(parseJsonArg<string[]>(readOption(args, "--preferred-agents"), []).length
+              ? { preferredAgents: parseJsonArg<string[]>(readOption(args, "--preferred-agents"), []) }
+              : {}),
+            ...(readOption(args, "--trigger-mode")
+              ? { triggerMode: readOption(args, "--trigger-mode") as "explicit" | "required" | "recommended" }
+              : {}),
+            ...(readOption(args, "--budget-tier")
+              ? { budgetTier: readOption(args, "--budget-tier") as "low" | "medium" | "high" }
+              : {}),
+            ...(readOption(args, "--prompt-patch") ? { promptPatch: readOption(args, "--prompt-patch") } : {}),
+          },
+        })
+      : buildPageRecord({
+          dbKey,
+          pageId: docId,
+          title,
+          spaceId,
+          content: body,
+          meta: description ? { description } : undefined,
+        });
+
+  const skillSummary = docKind === "skill" ? buildSkillSummaryMarker(record.meta) : undefined;
+  const summary = {
+    dryRun: shouldDryRun,
+    kind: docKind,
+    title,
+    dbKey,
+    id: docId,
+    userId,
+    spaceId,
+    syncTargets: targets,
+    writtenTargets: [] as string[],
+    secretFindingCount: secretFindings.length,
+    secretFindings,
+  };
+
+  if (!shouldDryRun) {
+    for (const serverUrl of targets) {
+      await writePageRecord({
+        authToken,
+        dbKey,
+        record,
+        serverUrl,
+        spaceId,
+        title,
+        userId,
+        skillSummary,
+      });
+      summary.writtenTargets.push(serverUrl);
+    }
+  }
+
+  if (shouldOutputJson) {
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+  } else if (shouldDryRun) {
+    process.stdout.write(`dry-run ok: ${dbKey}\n`);
+  } else {
+    process.stdout.write(`created ${docKind}: ${dbKey}\n`);
+  }
+
+  return 0;
+}
+
+export async function runDocCreateCommand(args: string[], deps: DocCreateDeps) {
+  return runCreateCommand(args, deps, {
+    defaultKind: "page",
+    usage: printDocCreateUsage,
+  });
+}
+
+export async function runSkillDocCreateCommand(args: string[], deps: DocCreateDeps) {
+  return runCreateCommand(args, deps, {
+    defaultKind: "skill",
+    usage: printSkillDocCreateUsage,
+  });
+}

package/docInternalCommandEntries.ts

@@ -0,0 +1,11 @@
+import type { CommandEntry } from "./cliCommandTypes";
+import { createEnvCommand } from "./cliCommandFactories";
+import { runDocCreateCommand, runSkillDocCreateCommand } from "./docCreateCommands";
+
+export function getDocInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["doc", "create"], "Create a normal doc", runDocCreateCommand),
+    createEnvCommand(["skill-doc", "create"], "Create a skill-backed doc", runSkillDocCreateCommand),
+    createEnvCommand(["skill", "create-doc"], "Create a skill-backed doc", runSkillDocCreateCommand),
+  ];
+}

package/docPageHelpers.ts

@@ -0,0 +1,80 @@
+import { readFileSync } from "node:fs";
+import { ulid } from "ulid";
+
+function getCliArg(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  return idx !== -1 ? args[idx + 1] : undefined;
+}
+
+export function readBodyArg(args: string[], fallback = "") {
+  const bodyFile = getCliArg(args, "--body-file");
+  if (bodyFile !== undefined) {
+    return readFileSync(bodyFile, "utf8");
+  }
+  return getCliArg(args, "--body") ?? fallback;
+}
+
+function textToSlate(text: string) {
+  return text.split("\n").map((line) => ({
+    type: "paragraph",
+    children: [{ text: line }],
+  }));
+}
+
+export function createPageId() {
+  return ulid();
+}
+
+export function buildPageKey(userId: string, pageId: string) {
+  return `page-${userId}-${pageId}`;
+}
+
+export function buildPageRecord(args: {
+  dbKey: string;
+  pageId: string;
+  title: string;
+  spaceId: string | null;
+  content: string;
+  existing?: Record<string, any> | null;
+  meta?: Record<string, any> | null;
+  slateData?: Record<string, any>[] | null;
+}) {
+  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: Record<string, any> = {
+    ...(existing ?? {}),
+    id: existing?.id ?? pageId,
+    dbKey,
+    type: "page",
+    title,
+    spaceId,
+    content,
+    updatedAt: now,
+    createdAt,
+    created,
+  };
+
+  if (meta !== undefined) {
+    if (meta === null) {
+      delete nextRecord.meta;
+    } else {
+      nextRecord.meta = meta;
+    }
+  }
+
+  if (slateData !== undefined) {
+    if (slateData === null) {
+      delete nextRecord.slateData;
+    } else {
+      nextRecord.slateData = slateData;
+    }
+  } else if (!existing?.slateData) {
+    nextRecord.slateData = textToSlate(content);
+  }
+
+  return nextRecord;
+}

package/docSkillHelpers.ts

@@ -0,0 +1,67 @@
+import {
+  buildSkillDocMarkdown,
+  type SkillDocConfig,
+} from "./ai/skills/skillDocProtocol";
+import { buildPageKey, buildPageRecord } from "./docPageHelpers";
+
+function normalizeSkillSeed(input: string) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function deterministicId(prefix: string, seed: string): string {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = (h * 0x01000193) >>> 0;
+  }
+  const suffix = h.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+
+export function buildSkillDocId(input: string) {
+  return deterministicId("01SK", normalizeSkillSeed(input) || input);
+}
+
+export function buildSkillPageKey(userId: string, skillId: string) {
+  return buildPageKey(userId, skillId);
+}
+
+export function buildSkillPageRecord(args: {
+  dbKey: string;
+  skillId: string;
+  title: string;
+  spaceId: string | null;
+  body: string;
+  skillConfig: SkillDocConfig;
+  existing?: Record<string, any> | null;
+}) {
+  const { dbKey, skillId, title, spaceId, body, skillConfig, existing } = args;
+  return {
+    ...buildPageRecord({
+      dbKey,
+      pageId: skillId,
+      title,
+      spaceId,
+      content: buildSkillDocMarkdown({
+        body,
+        skillConfig,
+      }),
+      existing,
+      meta: {
+        ...(existing?.meta ?? {}),
+        kind: "skill",
+        skillConfig,
+      },
+      slateData: null,
+    }),
+  };
+}
+
+export function parseJsonArg<T>(raw: string | undefined, fallback: T): T {
+  if (raw === undefined) return fallback;
+  return JSON.parse(raw) as T;
+}

package/docSpaceHelpers.ts

@@ -0,0 +1,46 @@
+import { createSpaceKey } from "./create/space/spaceKeys";
+import { readDbRecord, writeAgentRecord } from "./agentRecordHelpers";
+
+export async function ensurePageAttachedToSpace(params: {
+  baseUrl: string;
+  userId: string;
+  authToken: string;
+  spaceId: string;
+  contentKey: string;
+  title: string;
+  skillSummary?: Record<string, any> | null;
+}) {
+  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 !== undefined ? { skillSummary } : {}),
+          updatedAt: now,
+          createdAt: spaceRecord.contents?.[contentKey]?.createdAt ?? now,
+        },
+      },
+      updatedAt: now,
+    },
+  });
+}

package/integrations/anthropic/anthropicModels.ts

@@ -0,0 +1,47 @@
+// integrations/anthropic/anthropicModels.ts
+import { Model } from "../../ai/llm/types";
+
+export const anthropicModels: Model[] = [
+  {
+    name: "claude-3-5-sonnet-latest",
+    displayName: "Claude 3.5 Sonnet",
+    hasVision: true,
+    description: "Our most intelligent model to date",
+    contextWindow: 200000,
+    maxOutputTokens: 8192,
+    price: {
+      input: 27.0, // $3/MTok * 9
+      output: 135.0, // $15/MTok * 9
+      cachingWrite: 33.75, // $3.75/MTok * 9
+      cachingRead: 2.7, // $0.30/MTok * 9
+    },
+  },
+  {
+    name: "claude-3-7-sonnet-latest",
+    displayName: "Claude 3.7 Sonnet",
+    hasVision: true,
+    description: "Our most intelligent model to date",
+    contextWindow: 200000,
+    maxOutputTokens: 8192,
+    price: {
+      input: 27.0, // $3/MTok * 9
+      output: 135.0, // $15/MTok * 9
+      cachingWrite: 33.75, // $3.75/MTok * 9
+      cachingRead: 2.7, // $0.30/MTok * 9
+    },
+  },
+  {
+    name: "claude-3-5-haiku-20241022",
+    displayName: "Claude 3.5 Haiku",
+    hasVision: false,
+    description: "Fastest, most cost-effective model",
+    contextWindow: 200000,
+    maxOutputTokens: 8192,
+    price: {
+      input: 7.2, // $0.80/MTok * 9
+      output: 36.0, // $4/MTok * 9
+      cachingWrite: 9.0, // $1/MTok * 9
+      cachingRead: 0.72, // $0.08/MTok * 9
+    },
+  },
+];

package/integrations/deepseek/models.ts

@@ -0,0 +1,37 @@
+import { Model } from "../../ai/llm/types";
+
+// 备注: 因为是中文(国内服务直接人民币计价)，所以不用乘以 7
+export const deepSeekModels: Model[] = [
+  {
+    name: "deepseek-v4-flash",
+    displayName: "DeepSeek V4 Flash",
+    hasVision: false,
+    contextWindow: 1_000_000,
+    maxOutputTokens: 384_000,
+    jsonOutput: true,
+    fnCall: true,
+    supportsTool: true,
+    supportsReasoningEffort: true,
+    price: {
+      input: 1,
+      inputCacheHit: 0.02,
+      output: 2,
+    },
+  },
+  {
+    name: "deepseek-v4-pro",
+    displayName: "DeepSeek V4 Pro",
+    hasVision: false,
+    contextWindow: 1_000_000,
+    maxOutputTokens: 384_000,
+    jsonOutput: true,
+    fnCall: true,
+    supportsTool: true,
+    supportsReasoningEffort: true,
+    price: {
+      input: 3,
+      inputCacheHit: 0.1,
+      output: 6,
+    },
+  },
+];