nolo-cli 0.1.32 → 0.1.33

package/cli/pageUpdateCommands.ts

@@ -1,249 +0,0 @@
-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

@@ -1,209 +0,0 @@
-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

@@ -1,36 +0,0 @@
-/**
- * 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/runtimeInternalCommandEntries.ts

@@ -1,15 +0,0 @@
-import { createArgsCommand } from "./cliCommandFactories";
-import type { CommandEntry } from "./cliCommandTypes";
-import {
-  runDevPassthroughCommand,
-  runLlamaPassthroughCommand,
-  runModelRuntimePassthroughCommand,
-} from "./runtimePassthroughCommands";
-
-export function getRuntimeInternalCommandEntries(): CommandEntry[] {
-  return [
-    createArgsCommand(["llama"], "Manage the llama.cpp runtime", runLlamaPassthroughCommand),
-    createArgsCommand(["model-runtime"], "Manage local model runtime processes", runModelRuntimePassthroughCommand),
-    createArgsCommand(["dev"], "Manage the local dev environment", runDevPassthroughCommand),
-  ];
-}

package/cli/runtimePassthroughCommands.ts

@@ -1,22 +0,0 @@
-import { runScriptPassthrough, type ScriptPassthroughDeps } from "./scriptPassthroughHelpers";
-
-export async function runLlamaPassthroughCommand(
-  args: string[],
-  deps: ScriptPassthroughDeps = {}
-) {
-  return runScriptPassthrough("scripts/runtime/llamaServerSupervisor.ts", args, deps);
-}
-
-export async function runModelRuntimePassthroughCommand(
-  args: string[],
-  deps: ScriptPassthroughDeps = {}
-) {
-  return runScriptPassthrough("scripts/runtime/localModelRuntimeSupervisor.ts", args, deps);
-}
-
-export async function runDevPassthroughCommand(
-  args: string[],
-  deps: ScriptPassthroughDeps = {}
-) {
-  return runScriptPassthrough("scripts/dev/devControl.ts", args, deps);
-}

package/cli/scriptPassthroughHelpers.ts

@@ -1,28 +0,0 @@
-import path from "node:path";
-
-export type ScriptPassthroughDeps = {
-  env?: NodeJS.ProcessEnv;
-  spawnCommand?: (command: string[]) => Promise<number>;
-};
-
-async function defaultSpawnCommand(command: string[]) {
-  const proc = Bun.spawn({
-    cmd: command,
-    cwd: process.cwd(),
-    env: process.env,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "inherit",
-  });
-  return await proc.exited;
-}
-
-export async function runScriptPassthrough(
-  relativeScriptPath: string,
-  args: string[],
-  deps: ScriptPassthroughDeps = {}
-) {
-  const spawnCommand = deps.spawnCommand ?? defaultSpawnCommand;
-  const command = [process.execPath, path.join(process.cwd(), relativeScriptPath), ...args];
-  return await spawnCommand(command);
-}

package/cli/secretScanHelpers.ts

@@ -1,31 +0,0 @@
-export type SecretFinding = {
-  label: string;
-  line: number;
-  preview: string;
-};
-
-const SECRET_PATTERNS: Array<{ label: string; pattern: RegExp }> = [
-  { label: "password", pattern: /\bpassword\s*[:=]\s*["']?[^"',\s#]{8,}/i },
-  { label: "psk", pattern: /\bpsk\s*[:=]\s*["']?[^"',\s#]{8,}/i },
-  { label: "api key", pattern: /\b(api[_-]?key|apikey)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
-  { label: "token", pattern: /\b(token|secret)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
-  { label: "private key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
-];
-
-export function findPotentialSecrets(text: string): SecretFinding[] {
-  return text
-    .split(/\r?\n/)
-    .flatMap((line, index) =>
-      SECRET_PATTERNS.filter(({ pattern }) => pattern.test(line)).map(({ label }) => ({
-        label,
-        line: index + 1,
-        preview: line.length > 120 ? `${line.slice(0, 117)}...` : line,
-      }))
-    );
-}
-
-export function formatSecretFindings(findings: SecretFinding[]) {
-  return findings
-    .map((finding) => `  line ${finding.line} (${finding.label}): ${finding.preview}`)
-    .join("\n");
-}