nolo-cli 0.1.30 → 0.1.32

package/cli/pageReadCommands.ts

@@ -0,0 +1,151 @@
+import { parseSkillDocProtocol, resolvePageSkillMetadata } from "../ai/skills/skillDocProtocol";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { readDbRecord } from "./agentRecordHelpers";
+import {
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import { readRecordWithCandidates } from "./hybridReadHelpers";
+
+type PageReadResult = {
+  baseUrl: string;
+  dbKey: string;
+  title: string | null;
+  spaceId: string | null;
+  type: string | null;
+  content: string | null;
+  meta: Record<string, any> | null;
+  record: Record<string, any>;
+};
+
+function usage(command: "doc" | "skill-doc") {
+  return [
+    "Usage:",
+    `  nolo ${command} read <pageKey>`,
+    "",
+  ].join("\n");
+}
+
+async function readPageRecord(args: {
+  db: Awaited<ReturnType<typeof getReadableCliDb>>;
+  authToken: string;
+  dbKey: string;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  serverCandidates: string[];
+}) {
+  return await readRecordWithCandidates<Record<string, any>>({
+    db: args.db,
+    dbKey: args.dbKey,
+    serverCandidates: args.serverCandidates,
+    readRemote: async (serverUrl, dbKey) =>
+      readDbRecord({
+        authToken: args.authToken,
+        dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl,
+      }),
+  });
+}
+
+function buildPageReadResult(baseUrl: string, dbKey: string, record: Record<string, any>): PageReadResult {
+  return {
+    baseUrl,
+    dbKey,
+    title: record?.title ?? null,
+    spaceId: record?.spaceId ?? null,
+    type: record?.type ?? null,
+    content: typeof record?.content === "string" ? record.content : null,
+    meta: record?.meta && typeof record.meta === "object" ? record.meta : null,
+    record,
+  };
+}
+
+async function runBasePageReadCommand(
+  args: string[],
+  deps: AgentCommandDeps,
+  mode: "doc" | "skill-doc"
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const raw = args[0]?.trim();
+  if (!raw || raw === "-h" || raw === "--help") {
+    output.write(`${usage(mode)}\n`);
+    return raw ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write(`[nolo] ${mode} read requires an auth token. Run \`nolo login\` or set AUTH_TOKEN.\n`);
+    return 1;
+  }
+
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const defaultServerUrl = resolveServerUrl(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
+
+  try {
+    const record = await readPageRecord({
+      db,
+      authToken,
+      dbKey: raw,
+      fetchImpl,
+      fallbackFetchImpl,
+      serverCandidates,
+    });
+    const result = buildPageReadResult(defaultServerUrl, raw, record);
+
+    if (mode === "doc") {
+      output.write(`${JSON.stringify(result, null, 2)}\n`);
+      return 0;
+    }
+
+    const parsed = parseSkillDocProtocol(
+      typeof record?.content === "string" ? record.content : "",
+      record?.meta,
+      record?.tools
+    );
+    const meta = resolvePageSkillMetadata(record);
+    const skillConfig = meta?.skillConfig ?? null;
+
+    output.write(
+      `${JSON.stringify(
+        {
+          ...result,
+          isSkill: Boolean(meta?.kind === "skill" || skillConfig),
+          body: typeof parsed.content === "string" ? parsed.content : "",
+          meta: meta ?? result.meta,
+          skillConfig,
+        },
+        null,
+        2
+      )}\n`
+    );
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] ${mode} read failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runDocReadCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageReadCommand(args, deps, "doc");
+}
+
+export async function runSkillDocReadCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageReadCommand(args, deps, "skill-doc");
+}

package/cli/pageUpdateCommands.ts

@@ -0,0 +1,249 @@
+import { parseSkillDocProtocol, resolvePageSkillMetadata, type SkillDocConfig } from "../ai/skills/skillDocProtocol";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import { readDbRecord } from "./agentRecordHelpers";
+import {
+  parseUserIdFromAuthToken,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+import { readRecordWithCandidates } from "./hybridReadHelpers";
+import {
+  buildDocSpaceRecord,
+  buildPageRecord,
+  buildSkillPageRecord,
+  buildSkillSummaryFromRecord,
+  parseJsonOption,
+  readBodyOption,
+  readOption,
+  writeRemoteRecordsThenCache,
+} from "./pageWriteHelpers";
+
+function usage(command: "doc" | "skill-doc") {
+  return [
+    "Usage:",
+    `  nolo ${command} update --key <pageKey> [options]`,
+    "",
+  ].join("\n");
+}
+
+async function readRecord(args: {
+  authToken: string;
+  db: Awaited<ReturnType<typeof getReadableCliDb>>;
+  dbKey: string;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  serverCandidates: string[];
+}) {
+  return readRecordWithCandidates<Record<string, any>>({
+    db: args.db,
+    dbKey: args.dbKey,
+    serverCandidates: args.serverCandidates,
+    readRemote: async (serverUrl, dbKey) =>
+      readDbRecord({
+        authToken: args.authToken,
+        dbKey,
+        fallbackFetchImpl: args.fallbackFetchImpl,
+        fetchImpl: args.fetchImpl,
+        serverUrl,
+      }),
+  });
+}
+
+async function runBasePageUpdateCommand(
+  args: string[],
+  deps: AgentCommandDeps,
+  mode: "doc" | "skill-doc"
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const dbKey = readOption(args, "--key");
+  if (!dbKey || dbKey === "-h" || dbKey === "--help") {
+    output.write(`${usage(mode)}\n`);
+    return dbKey ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!authToken || !userId) {
+    output.write(`[nolo] ${mode} update requires an auth token with userId. Run \`nolo login\`.\n`);
+    return 1;
+  }
+
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+  const defaultServerUrl = resolveServerUrl(args, env);
+  const serverCandidates = resolveServerCandidates(args, env, defaultServerUrl);
+  const writeTargets = [defaultServerUrl];
+
+  try {
+    const existing = await readRecord({
+      authToken,
+      db,
+      dbKey,
+      fetchImpl,
+      fallbackFetchImpl,
+      serverCandidates,
+    });
+    const spaceId = readOption(args, "--space") ?? (typeof existing?.spaceId === "string" ? existing.spaceId : null);
+    if (!spaceId) {
+      throw new Error(`unable to resolve space for ${dbKey}`);
+    }
+
+    const spaceKey = `space-${spaceId}`;
+    const existingSpaceRecord = await readRecord({
+      authToken,
+      db,
+      dbKey: spaceKey,
+      fetchImpl,
+      fallbackFetchImpl,
+      serverCandidates,
+    });
+
+    if (mode === "doc") {
+      if (existing?.meta?.kind === "skill") {
+        throw new Error(`target page is a skill doc; use \`nolo skill-doc update --key ${dbKey}\``);
+      }
+      const title = readOption(args, "--title") ?? existing?.title;
+      if (!title) {
+        throw new Error(`missing title for ${dbKey}`);
+      }
+      const content = readBodyOption(args, typeof existing?.content === "string" ? existing.content : "");
+      const pageId =
+        typeof existing?.id === "string" && existing.id.trim()
+          ? existing.id
+          : dbKey.split("-").slice(-1)[0];
+      const pageRecord = buildPageRecord({
+        content,
+        dbKey,
+        existing,
+        meta: existing?.meta ?? undefined,
+        pageId,
+        spaceId,
+        title,
+      });
+      const spaceRecord = buildDocSpaceRecord({
+        contentKey: dbKey,
+        existingSpaceRecord,
+        spaceId,
+        title,
+      });
+
+      await writeRemoteRecordsThenCache({
+        authToken,
+        db,
+        fetchImpl,
+        fallbackFetchImpl,
+        records: [
+          ...writeTargets.map((serverUrl) => ({ dbKey, record: pageRecord, serverUrl })),
+          ...writeTargets.map((serverUrl) => ({ dbKey: spaceKey, record: spaceRecord, serverUrl })),
+        ],
+        userId,
+      });
+
+      output.write(`${JSON.stringify({ ok: true, dbKey, spaceKey, baseUrl: defaultServerUrl }, null, 2)}\n`);
+      return 0;
+    }
+
+    const parsed = parseSkillDocProtocol(
+      typeof existing?.content === "string" ? existing.content : "",
+      existing?.meta,
+      existing?.tools
+    );
+    const metadata = resolvePageSkillMetadata(existing);
+    const currentConfig = metadata?.skillConfig;
+    if (!currentConfig) {
+      throw new Error(`target page is not a skill doc: ${dbKey}`);
+    }
+
+    const title = readOption(args, "--title") ?? existing?.title ?? currentConfig.name;
+    const description = readOption(args, "--description") ?? currentConfig.description;
+    if (!title || !description) {
+      throw new Error(`skill doc requires title and description: ${dbKey}`);
+    }
+    const mergedSkillConfig: SkillDocConfig = {
+      ...currentConfig,
+      name: title,
+      description,
+      ...(readOption(args, "--tools") !== undefined
+        ? { toolNames: parseJsonOption<string[]>(readOption(args, "--tools"), []) }
+        : {}),
+      ...(readOption(args, "--required-skills") !== undefined
+        ? { requiredSkills: parseJsonOption<string[]>(readOption(args, "--required-skills"), []) }
+        : {}),
+      ...(readOption(args, "--recommended-skills") !== undefined
+        ? { recommendedSkills: parseJsonOption<string[]>(readOption(args, "--recommended-skills"), []) }
+        : {}),
+      ...(readOption(args, "--preferred-agents") !== undefined
+        ? { preferredAgents: parseJsonOption<string[]>(readOption(args, "--preferred-agents"), []) }
+        : {}),
+      ...(readOption(args, "--trigger-mode") !== undefined
+        ? { triggerMode: readOption(args, "--trigger-mode") as SkillDocConfig["triggerMode"] }
+        : {}),
+      ...(readOption(args, "--budget-tier") !== undefined
+        ? { budgetTier: readOption(args, "--budget-tier") as SkillDocConfig["budgetTier"] }
+        : {}),
+      ...(readOption(args, "--prompt-patch") !== undefined
+        ? { promptPatch: readOption(args, "--prompt-patch") || undefined }
+        : {}),
+    };
+    const body = readBodyOption(args, parsed.content ?? "");
+    const skillId =
+      typeof existing?.id === "string" && existing.id.trim()
+        ? existing.id
+        : dbKey.split("-").slice(-1)[0];
+    const pageRecord = buildSkillPageRecord({
+      body,
+      dbKey,
+      existing,
+      skillConfig: mergedSkillConfig,
+      skillId,
+      spaceId,
+      title,
+    });
+    const spaceRecord = buildDocSpaceRecord({
+      contentKey: dbKey,
+      existingSpaceRecord,
+      skillSummary: buildSkillSummaryFromRecord(pageRecord),
+      spaceId,
+      title,
+    });
+
+    await writeRemoteRecordsThenCache({
+      authToken,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      records: [
+        ...writeTargets.map((serverUrl) => ({ dbKey, record: pageRecord, serverUrl })),
+        ...writeTargets.map((serverUrl) => ({ dbKey: spaceKey, record: spaceRecord, serverUrl })),
+      ],
+      userId,
+    });
+
+    output.write(`${JSON.stringify({ ok: true, dbKey, spaceKey, baseUrl: defaultServerUrl }, null, 2)}\n`);
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] ${mode} update failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runDocUpdateCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageUpdateCommand(args, deps, "doc");
+}
+
+export async function runSkillDocUpdateCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  return runBasePageUpdateCommand(args, deps, "skill-doc");
+}

package/cli/pageWriteHelpers.ts

@@ -0,0 +1,209 @@
+import { readFileSync } from "node:fs";
+import { buildSkillDocMarkdown, type SkillDocConfig } from "../ai/skills/skillDocProtocol";
+import { buildSkillSummaryMarker } from "../ai/skills/skillSummaryMarker";
+import { ContentType, type SpaceContent } from "../app/types";
+import { createSpaceKey } from "../create/space/spaceKeys";
+import { ulid } from "ulid";
+import { writeDbRecord } from "./agentRecordHelpers";
+import type { CliKvDb } from "./client/hybridRecordStore";
+
+export async function writeRemoteRecordsThenCache(args: {
+  authToken: string;
+  db: CliKvDb;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  records: Array<{
+    dbKey: string;
+    record: Record<string, any>;
+    serverUrl: string;
+  }>;
+  userId: string;
+}) {
+  for (const item of args.records) {
+    await writeDbRecord({
+      authToken: args.authToken,
+      dbKey: item.dbKey,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      record: item.record,
+      serverUrl: item.serverUrl,
+      userId: args.userId,
+    });
+  }
+
+  for (const item of args.records) {
+    await args.db.put(item.dbKey, item.record);
+  }
+}
+
+export function readBodyOption(args: string[], fallback = "") {
+  const bodyFile = readOption(args, "--body-file");
+  if (bodyFile !== undefined) {
+    return readFileSync(bodyFile, "utf8");
+  }
+  return readOption(args, "--body") ?? fallback;
+}
+
+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 { content, dbKey, existing, meta, pageId, slateData, spaceId, title } = 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;
+    }
+  }
+
+  return nextRecord;
+}
+
+export function buildSkillPageRecord(args: {
+  dbKey: string;
+  skillId: string;
+  title: string;
+  spaceId: string | null;
+  body: string;
+  skillConfig: SkillDocConfig;
+  existing?: Record<string, any> | null;
+}) {
+  const { body, dbKey, existing, skillConfig, skillId, spaceId, title } = args;
+  return buildPageRecord({
+    dbKey,
+    pageId: skillId,
+    title,
+    spaceId,
+    content: buildSkillDocMarkdown({ body, skillConfig }),
+    existing,
+    meta: {
+      ...(existing?.meta ?? {}),
+      kind: "skill",
+      skillConfig,
+    },
+    slateData: null,
+  });
+}
+
+export function buildDocSpaceRecord(args: {
+  contentKey: string;
+  spaceId: string;
+  title: string;
+  existingSpaceRecord: Record<string, any>;
+  skillSummary?: SpaceContent["skillSummary"] | null;
+}) {
+  const { contentKey, existingSpaceRecord, skillSummary, spaceId, title } = args;
+  const now = Date.now();
+  const existingContent = existingSpaceRecord?.contents?.[contentKey];
+
+  return {
+    ...existingSpaceRecord,
+    dbKey: createSpaceKey.space(spaceId),
+    updatedAt: now,
+    contents: {
+      ...(existingSpaceRecord?.contents ?? {}),
+      [contentKey]: {
+        ...(existingContent ?? {}),
+        title,
+        type: ContentType.DOC,
+        contentKey,
+        ...(skillSummary !== undefined ? { skillSummary } : {}),
+        updatedAt: now,
+        createdAt: existingContent?.createdAt ?? now,
+      },
+    },
+  };
+}
+
+export function buildSkillSummaryFromRecord(record: Record<string, any>) {
+  return buildSkillSummaryMarker(record?.meta);
+}
+
+export function buildDetachedDocSpaceRecord(args: {
+  contentKey: string;
+  existingSpaceRecord: Record<string, any>;
+  spaceId: string;
+}) {
+  const { contentKey, existingSpaceRecord, spaceId } = args;
+  const nextContents = { ...(existingSpaceRecord?.contents ?? {}) };
+  delete nextContents[contentKey];
+  return {
+    ...existingSpaceRecord,
+    dbKey: createSpaceKey.space(spaceId),
+    updatedAt: Date.now(),
+    contents: nextContents,
+  };
+}
+
+export function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+export function parseJsonOption<T>(raw: string | undefined, fallback: T): T {
+  if (raw === undefined) return fallback;
+  return JSON.parse(raw) as T;
+}
+
+export function createPageId() {
+  return ulid();
+}
+
+export function buildPageKey(userId: string, pageId: string) {
+  return `page-${userId}-${pageId}`;
+}
+
+export function normalizeSkillSeed(input: string) {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+export function deterministicId(prefix: string, seed: string) {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash ^= seed.charCodeAt(index);
+    hash = (hash * 0x01000193) >>> 0;
+  }
+  const suffix = hash.toString(36).toUpperCase().padStart(14, "0");
+  return (prefix + suffix).slice(0, 26);
+}
+
+export function buildSkillDocId(input: string) {
+  return deterministicId("01SK", normalizeSkillSeed(input) || input);
+}

package/cli/publishPackage.ts

@@ -0,0 +1,36 @@
+/**
+ * Build a publish-safe package.json manifest by removing workspace dependencies.
+ * 
+ * Workspace dependencies (e.g., "workspace:*") should not be published to npm
+ * as they only resolve within the monorepo workspace.
+ * 
+ * @param manifest - The input package.json manifest object
+ * @returns A new manifest with workspace dependencies removed
+ */
+export function buildPublishManifest(manifest: Record<string, any>): Record<string, any> {
+  const result = { ...manifest };
+
+  // Strip workspace deps from all dependency fields
+  const depFields = ["dependencies", "devDependencies", "peerDependencies"] as const;
+  
+  for (const field of depFields) {
+    if (result[field]) {
+      const filtered: Record<string, string> = {};
+      for (const [name, version] of Object.entries(result[field])) {
+        // Skip workspace: protocol dependencies
+        if (typeof version === "string" && !version.startsWith("workspace:")) {
+          filtered[name] = version;
+        }
+      }
+      
+      // Only set the field if there are non-workspace deps
+      if (Object.keys(filtered).length > 0) {
+        result[field] = filtered;
+      } else {
+        delete result[field];
+      }
+    }
+  }
+
+  return result;
+}

package/cli/runtimeDoctorCommands.ts

@@ -0,0 +1,67 @@
+import {
+  type AgentCommandDeps,
+  type LocalRuntimeProbeResult,
+} from "./agentCommandSupport";
+import {
+  buildCliRuntimeDoctorProbe,
+  buildCliRuntimeDoctorReport,
+  formatCliRuntimeDoctorReport,
+} from "./cliRuntimeDoctorReport";
+import {
+  resolveAuthToken,
+  resolveServerUrl,
+  type EnvLike,
+} from "./cliEnvHelpers";
+
+function readLocalAgentKey(env: EnvLike) {
+  return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
+}
+
+async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
+  const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb");
+  const dbPath = resolveCliLocalRuntimeDbPath({ env });
+  const agentKey = readLocalAgentKey(env);
+  try {
+    const { getDefaultCliLocalRuntimeDb } = await import("./localRuntimeDb");
+    const db = await getDefaultCliLocalRuntimeDb();
+    if (!agentKey) {
+      return { ok: true, dbPath, agentFound: false };
+    }
+    try {
+      await db.get(agentKey);
+      return { ok: true, dbPath, agentFound: true, agentKey };
+    } catch {
+      return { ok: true, dbPath, agentFound: false, agentKey };
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      dbPath,
+      agentFound: false,
+      ...(agentKey ? { agentKey } : {}),
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function runDoctorRuntimeCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(args, env);
+  const serverUrl = resolveServerUrl(args, env);
+  const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
+  const report = buildCliRuntimeDoctorReport(
+    buildCliRuntimeDoctorProbe({
+      env,
+      localProbe,
+      authToken,
+      serverUrl,
+    })
+  );
+  output.write(formatCliRuntimeDoctorReport(report));
+
+  return report.decision.runnable ? 0 : 1;
+}