nolo-cli 0.1.32 → 0.1.33

package/cli/dialogReadCommands.ts

@@ -1,180 +0,0 @@
-import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
-import {
-  resolveAuthToken,
-  resolveServerCandidates,
-} from "./cliEnvHelpers";
-import {
-  isLocalBaseUrl,
-  readDialogFromLocalDb,
-  tryHttpDialogCandidates,
-} from "./dialogDataAccess";
-import {
-  buildDialogReadResult,
-  parseDialogInputForCli,
-  type DialogHttpAttempt,
-  type DialogReadSource,
-} from "./dialogReadHelpers";
-
-function usage() {
-  return [
-    "Usage:",
-    "  nolo dialog read <dialogId|dialogUrl> [limit]",
-    "",
-  ].join("\n");
-}
-
-function isHelpArg(value?: string) {
-  return value === "-h" || value === "--help";
-}
-
-function parseArgs(args: string[]) {
-  const rawInput = args[0]?.trim();
-  if (!rawInput || isHelpArg(rawInput)) return { help: true as const };
-  const rawLimit = args[1]?.trim() || "50";
-  if (!/^\d+$/.test(rawLimit)) {
-    throw new Error("limit must be a number");
-  }
-  return {
-    help: false as const,
-    rawInput,
-    limit: Number(rawLimit),
-  };
-}
-
-export async function runDialogReadCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  let parsedArgs: ReturnType<typeof parseArgs>;
-  try {
-    parsedArgs = parseArgs(args);
-  } catch (error) {
-    output.write(`[nolo] dialog read failed: ${error instanceof Error ? error.message : String(error)}\n`);
-    return 1;
-  }
-
-  if (parsedArgs.help) {
-    output.write(`${usage()}\n`);
-    return args[0] ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-
-  try {
-    const { base, dialogId, userId, spaceId } = parseDialogInputForCli(parsedArgs.rawInput, env);
-    const dialogKey = `dialog-${userId}-${dialogId}`;
-    const candidateBases = resolveServerCandidates(
-      args,
-      {
-        ...env,
-        BASE_URL: env.READ_DIALOG_BASE?.trim() || base || env.BASE_URL,
-      },
-      base
-    );
-    let meta: any;
-    let msgs: any;
-    let source: DialogReadSource;
-    let resolvedBase = base;
-    let attempts: DialogHttpAttempt[] = [];
-
-    try {
-      ({ meta, msgs, source, resolvedBase, attempts } = await tryHttpDialogCandidates({
-        authToken,
-        bases: candidateBases,
-        dialogId,
-        dialogKey,
-        fetchImpl,
-        fallbackFetchImpl,
-        limit: parsedArgs.limit,
-      }));
-    } catch (error) {
-      attempts =
-        typeof error === "object" && error !== null && "attempts" in error
-          ? ((error as any).attempts as DialogHttpAttempt[])
-          : attempts;
-      const statuses = attempts
-        .map((attempt) => attempt.status)
-        .filter((status): status is number => typeof status === "number");
-      const all404 =
-        attempts.length > 0 &&
-        statuses.length === attempts.length &&
-        statuses.every((status) => status === 404);
-      const any401 = statuses.includes(401);
-      const localhostCandidate = candidateBases.find(isLocalBaseUrl);
-
-      if (!localhostCandidate) {
-        if (any401) {
-          throw new Error(
-            `read dialog failed across candidates (${candidateBases.join(", ")}). Hint: set AUTH_TOKEN to a current login token.`
-          );
-        }
-        throw new Error(
-          `read dialog failed across candidates: ${attempts
-            .map((attempt) => `${attempt.base} -> ${attempt.status ?? attempt.message}`)
-            .join("; ")}`
-        );
-      }
-
-      if (all404) {
-        throw new Error(
-          `read dialog failed: dialog not found on tried servers. Tried: ${candidateBases.join(", ")}`
-        );
-      }
-
-      try {
-        const db = deps.db ?? await getReadableCliDb(output);
-        ({ meta, msgs, source } = await readDialogFromLocalDb({
-          db,
-          dialogId,
-          dialogKey,
-          limit: parsedArgs.limit,
-        }));
-        resolvedBase = localhostCandidate;
-      } catch (fallbackError) {
-        const fallbackMessage =
-          fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
-        if (any401) {
-          throw new Error(
-            `read dialog failed: HTTP auth was rejected, and local DB fallback is unavailable (${fallbackMessage}). Hint: set AUTH_TOKEN to a current login token.`
-          );
-        }
-        throw new Error(
-          `read dialog failed: HTTP candidates were ${attempts
-            .map((attempt) => `${attempt.base} -> ${attempt.status ?? attempt.message}`)
-            .join("; ")}; local DB fallback also failed (${fallbackMessage})`
-        );
-      }
-    }
-
-    output.write(
-      `${JSON.stringify(
-        buildDialogReadResult({
-          source,
-          resolvedBase,
-          candidateBases,
-          attempts,
-          spaceId,
-          dialogId,
-          dialogKey,
-          userId,
-          meta,
-          msgs,
-        }),
-        null,
-        2
-      )}\n`
-    );
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] dialog read failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}

package/cli/dialogReadHelpers.ts

@@ -1,226 +0,0 @@
-import { normalizeSpaceId } from "../create/space/spaceKeys";
-import { parseUserIdFromAuthToken, resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
-
-export type DialogReadSource = "http" | "local-db-fallback";
-
-export type DialogHttpAttempt = {
-  base: string;
-  ok: boolean;
-  status?: number;
-  message?: string;
-};
-
-export type ParsedDialogInput = {
-  base: string;
-  dialogId: string;
-  userId: string;
-  spaceId?: string;
-};
-
-const DIALOG_PATH_RE = /^\/dialog-(.+)-([0-9A-HJKMNP-TV-Z]{26})$/i;
-const SPACE_DIALOG_PATH_RE =
-  /^\/space\/([^/]+)\/dialog-(.+)-([0-9A-HJKMNP-TV-Z]{26})$/i;
-
-function normalizeBaseUrl(base: string) {
-  return base.trim().replace(/\/+$/, "");
-}
-
-function toToolName(value: unknown) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function countByName(values: string[]) {
-  return values.reduce<Record<string, number>>((acc, value) => {
-    acc[value] = (acc[value] ?? 0) + 1;
-    return acc;
-  }, {});
-}
-
-function uniq(values: string[]) {
-  return [...new Set(values.filter(Boolean))];
-}
-
-function parseJsonObject(raw: unknown): Record<string, any> | null {
-  if (typeof raw !== "string" || !raw.trim()) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function deriveWrittenFiles(toolMessages: any[]) {
-  const writeToolNames = new Set([
-    "applyEdit",
-    "applyLineEdits",
-    "writeFile",
-    "createDoc",
-    "updateDoc",
-  ]);
-  const files: string[] = [];
-  for (const message of toolMessages) {
-    const toolName = toToolName(message?.toolName ?? message?.name);
-    if (!writeToolNames.has(toolName)) continue;
-    const payload = message?.toolPayload ?? {};
-    const content = parseJsonObject(message?.content);
-    const candidates = [
-      payload?.input?.filePath,
-      payload?.response?.filePath,
-      content?.filePath,
-    ];
-    for (const candidate of candidates) {
-      const normalized = typeof candidate === "string" ? candidate.trim() : "";
-      if (normalized) files.push(normalized);
-    }
-  }
-  return uniq(files);
-}
-
-function deriveToolErrors(toolMessages: any[]) {
-  const errors: string[] = [];
-  for (const message of toolMessages) {
-    const toolName = toToolName(message?.toolName ?? message?.name);
-    const payload = message?.toolPayload ?? {};
-    const content = parseJsonObject(message?.content);
-    if (payload?.status === "failed") {
-      errors.push(toolName || "unknown-tool");
-      continue;
-    }
-    if (content?.ok === false || content?.applied === false || content?.success === false) {
-      errors.push(toolName || "unknown-tool");
-    }
-  }
-  return uniq(errors);
-}
-
-export function parseDialogInputForCli(
-  rawInput: string,
-  env: Record<string, string | undefined>
-): ParsedDialogInput {
-  const authUserId = parseUserIdFromAuthToken(resolveAuthToken(env));
-  const envUserId = env.USER_ID?.trim() || authUserId;
-  const fallbackBase = normalizeBaseUrl(env.READ_DIALOG_BASE || resolveServerUrl(env));
-
-  if (!(rawInput.startsWith("http://") || rawInput.startsWith("https://"))) {
-    if (!envUserId) {
-      throw new Error("dialog read could not resolve userId; set AUTH_TOKEN or USER_ID.");
-    }
-    return {
-      base: fallbackBase,
-      dialogId: rawInput.trim(),
-      userId: envUserId,
-    };
-  }
-
-  const url = new URL(rawInput);
-  const spaceMatch = url.pathname.match(SPACE_DIALOG_PATH_RE);
-  if (spaceMatch) {
-    const [, spaceIdFromPath, userIdFromPath, dialogId] = spaceMatch;
-    return {
-      base: normalizeBaseUrl(env.READ_DIALOG_BASE || url.origin),
-      dialogId,
-      userId: env.USER_ID?.trim() || userIdFromPath || envUserId,
-      spaceId: normalizeSpaceId(spaceIdFromPath),
-    };
-  }
-
-  const match = url.pathname.match(DIALOG_PATH_RE);
-  if (!match) {
-    throw new Error(`Unsupported dialog URL path: ${url.pathname}`);
-  }
-
-  const [, userIdFromPath, dialogId] = match;
-  return {
-    base: normalizeBaseUrl(env.READ_DIALOG_BASE || url.origin),
-    dialogId,
-    userId: env.USER_ID?.trim() || userIdFromPath || envUserId,
-    spaceId: url.searchParams.get("spaceId") ?? undefined,
-  };
-}
-
-export function buildDialogReadResult(args: {
-  source: DialogReadSource;
-  resolvedBase: string;
-  candidateBases: string[];
-  attempts: DialogHttpAttempt[];
-  spaceId?: string;
-  dialogId: string;
-  dialogKey: string;
-  userId: string;
-  meta: any;
-  msgs: any;
-}) {
-  const orderedMsgs = Array.isArray(args.msgs) ? [...args.msgs].reverse() : args.msgs;
-  const lastAssistantMessage = Array.isArray(orderedMsgs)
-    ? [...orderedMsgs].reverse().find(
-        (message) => message?.role === "assistant" || message?.authorRole === "assistant"
-      )
-    : null;
-  const toolMessages = Array.isArray(orderedMsgs)
-    ? orderedMsgs.filter((message) => message?.role === "tool" || message?.authorRole === "tool")
-    : [];
-  const toolNamesFromMessages = toolMessages
-    .map((message) => toToolName(message?.toolName ?? message?.name))
-    .filter(Boolean);
-  const toolsUsed =
-    Array.isArray(args.meta?.toolsUsed) && args.meta.toolsUsed.length > 0
-      ? args.meta.toolsUsed.map((tool: unknown) => toToolName(tool)).filter(Boolean)
-      : uniq(toolNamesFromMessages);
-  const writtenFiles =
-    Array.isArray(args.meta?.writtenFiles) && args.meta.writtenFiles.length > 0
-      ? uniq(
-          args.meta.writtenFiles
-            .map((value: unknown) => (typeof value === "string" ? value.trim() : ""))
-            .filter(Boolean)
-        )
-      : deriveWrittenFiles(toolMessages);
-  const toolErrors =
-    Array.isArray(args.meta?.toolErrors) && args.meta.toolErrors.length > 0
-      ? uniq(
-          args.meta.toolErrors
-            .map((value: unknown) => (typeof value === "string" ? value.trim() : ""))
-            .filter(Boolean)
-        )
-      : deriveToolErrors(toolMessages);
-
-  return {
-    source: args.source,
-    base: args.resolvedBase,
-    triedBases: args.candidateBases,
-    httpAttempts: args.attempts,
-    spaceId: args.spaceId,
-    dialogId: args.dialogId,
-    dialogKey: args.dialogKey,
-    userId: args.userId,
-    title: args.meta?.title ?? null,
-    cybots: Array.isArray(args.meta?.cybots) ? args.meta.cybots : [],
-    category: args.meta?.category ?? null,
-    inheritedFromDialogKey: args.meta?.inheritedFromDialogKey ?? null,
-    inheritedFromDialogTitle: args.meta?.inheritedFromDialogTitle ?? null,
-    parentDialogId: args.meta?.parentDialogId ?? null,
-    rootDialogId: args.meta?.rootDialogId ?? null,
-    status: args.meta?.status,
-    errorMessage: args.meta?.errorMessage ?? null,
-    runtimeCheckpoint: args.meta?.runtimeCheckpoint ?? null,
-    durationMs: args.meta?.durationMs,
-    finishedAt: args.meta?.finishedAt,
-    createdAt: args.meta?.createdAt,
-    updatedAt: args.meta?.updatedAt,
-    artifacts: args.meta?.artifacts ?? null,
-    writtenFiles,
-    toolsUsed,
-    toolErrors,
-    toolSummary: {
-      metaToolsCount: toolsUsed.length,
-      metaToolsUnique: [...new Set(toolsUsed)],
-      toolMessageCount: toolMessages.length,
-      toolNamesFromMessages: [...new Set(toolNamesFromMessages)],
-      toolMessageCountsByName: countByName(toolNamesFromMessages),
-    },
-    agentReply: args.meta?.agentReply ?? null,
-    messagesCount: Array.isArray(orderedMsgs) ? orderedMsgs.length : 0,
-    lastAssistantMessage,
-    messages: orderedMsgs,
-  };
-}

package/cli/dialogStatusCommands.ts

@@ -1,123 +0,0 @@
-import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
-import { resolveAuthToken, resolveServerCandidates } from "./cliEnvHelpers";
-import {
-  isLocalBaseUrl,
-  readDialogFromLocalDb,
-  tryHttpDialogCandidates,
-} from "./dialogDataAccess";
-import {
-  parseDialogInputForCli,
-  type DialogHttpAttempt,
-} from "./dialogReadHelpers";
-import { renderDialogStatus } from "../agent-runtime/dialogStatus";
-
-function usage() {
-  return [
-    "Usage:",
-    "  nolo dialog status <dialogId|dialogUrl>",
-    "",
-  ].join("\n");
-}
-
-export async function runDialogStatusCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const rawInput = args[0]?.trim();
-  if (!rawInput || rawInput === "-h" || rawInput === "--help") {
-    output.write(`${usage()}\n`);
-    return rawInput ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-
-  try {
-    const { base, dialogId, userId } = parseDialogInputForCli(rawInput, env);
-    const dialogKey = `dialog-${userId}-${dialogId}`;
-    const candidateBases = resolveServerCandidates(
-      args,
-      {
-        ...env,
-        BASE_URL: env.READ_DIALOG_BASE?.trim() || base || env.BASE_URL,
-      },
-      base
-    );
-
-    let meta: any;
-    let resolvedBase = base;
-
-    try {
-      ({ meta, resolvedBase } = await tryHttpDialogCandidates({
-        authToken,
-        bases: candidateBases,
-        dialogId,
-        dialogKey,
-        fetchImpl,
-        fallbackFetchImpl,
-        limit: 1,
-      }));
-    } catch (error) {
-      const localhostCandidate = candidateBases.find(isLocalBaseUrl);
-      if (!localhostCandidate) {
-        const attempts =
-          typeof error === "object" && error !== null && "attempts" in error
-            ? ((error as any).attempts as DialogHttpAttempt[])
-            : [];
-        throw new Error(
-          `read dialog status failed: ${attempts
-            .map((attempt) => `${attempt.base} -> ${attempt.status ?? attempt.message}`)
-            .join("; ")}`
-        );
-      }
-      try {
-        const db = deps.db ?? await getReadableCliDb(output);
-        ({ meta } = await readDialogFromLocalDb({
-          db,
-          dialogId,
-          dialogKey,
-          limit: 1,
-        }));
-        resolvedBase = localhostCandidate;
-      } catch (fallbackError) {
-        throw new Error(
-          `read dialog status failed: ${
-            fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
-          }`
-        );
-      }
-    }
-
-    output.write(
-      renderDialogStatus({
-        dialogId,
-        dialogKey,
-        base: resolvedBase,
-        title: meta?.title ?? null,
-        status: meta?.status ?? null,
-        parentDialogId: meta?.parentDialogId ?? null,
-        rootDialogId: meta?.rootDialogId ?? null,
-        subjectRefs: Array.isArray(meta?.subjectRefs) ? meta.subjectRefs : [],
-        runtimeCheckpoint: meta?.runtimeCheckpoint ?? null,
-        artifacts: meta?.artifacts ?? null,
-        writtenFiles: Array.isArray(meta?.writtenFiles) ? meta.writtenFiles : [],
-        toolsUsed: Array.isArray(meta?.toolsUsed) ? meta.toolsUsed : [],
-        toolErrors: Array.isArray(meta?.toolErrors) ? meta.toolErrors : [],
-        durationMs: typeof meta?.durationMs === "number" ? meta.durationMs : null,
-        updatedAt: meta?.updatedAt ?? null,
-        finishedAt: meta?.finishedAt ?? null,
-      })
-    );
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] dialog status failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}

package/cli/docInternalCommandEntries.ts

@@ -1,20 +0,0 @@
-import { createEnvCommand } from "./cliCommandFactories";
-import type { CommandEntry } from "./cliCommandTypes";
-import { runDocCreateCommand, runSkillDocCreateCommand } from "./pageCreateCommands";
-import { runDocDeleteCommand, runSkillDocDeleteCommand } from "./pageDeleteCommands";
-import { runDocReadCommand, runSkillDocReadCommand } from "./pageReadCommands";
-import { runDocUpdateCommand, runSkillDocUpdateCommand } from "./pageUpdateCommands";
-
-export function getDocInternalCommandEntries(): CommandEntry[] {
-  return [
-    createEnvCommand(["doc", "create"], "Create a normal doc", runDocCreateCommand),
-    createEnvCommand(["doc", "read"], "Read a normal doc", runDocReadCommand),
-    createEnvCommand(["doc", "update"], "Update a normal doc", runDocUpdateCommand),
-    createEnvCommand(["doc", "delete"], "Delete a normal doc", runDocDeleteCommand),
-    createEnvCommand(["skill-doc", "create"], "Create a skill doc", runSkillDocCreateCommand),
-    createEnvCommand(["skill-doc", "read"], "Read a skill doc", runSkillDocReadCommand),
-    createEnvCommand(["skill-doc", "update"], "Update a skill doc", runSkillDocUpdateCommand),
-    createEnvCommand(["skill-doc", "delete"], "Delete a skill doc", runSkillDocDeleteCommand),
-    createEnvCommand(["skill", "create-doc"], "Create a skill-backed doc", runSkillDocCreateCommand),
-  ];
-}

package/cli/hybridReadHelpers.ts

@@ -1,109 +0,0 @@
-type LocalReadableDb = {
-  get: (key: string) => Promise<unknown>;
-};
-
-export type HybridReadSource = "local-cache" | "remote-cache";
-
-export type CandidateReadResult<T> = {
-  value: T;
-  serverUrl: string;
-};
-
-export type ReadThroughResult<T> = {
-  value: T;
-  source: HybridReadSource;
-  serverUrl: string | null;
-};
-
-export async function readFromServerCandidates<T>(args: {
-  serverCandidates: string[];
-  readRemote: (serverUrl: string) => Promise<T>;
-}): Promise<CandidateReadResult<T>> {
-  let lastError: Error | null = null;
-  for (const serverUrl of args.serverCandidates) {
-    try {
-      return {
-        value: await args.readRemote(serverUrl),
-        serverUrl,
-      };
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-    }
-  }
-
-  throw lastError ?? new Error("record not found from candidate servers");
-}
-
-export async function readThroughRecord<T>(args: {
-  db: LocalReadableDb;
-  dbKey: string;
-  serverCandidates: string[];
-  readRemote: (serverUrl: string, dbKey: string) => Promise<T>;
-  cacheRemote?: (value: T, serverUrl: string) => unknown | Promise<unknown>;
-  isReadableLocal?: (value: unknown) => value is T;
-}): Promise<ReadThroughResult<T>> {
-  try {
-    const local = await args.db.get(args.dbKey);
-    const isReadableLocal =
-      args.isReadableLocal ?? ((value: unknown): value is T => !!value && typeof value === "object");
-    if (isReadableLocal(local)) {
-      return {
-        value: local,
-        source: "local-cache",
-        serverUrl: null,
-      };
-    }
-  } catch {
-    // local miss; fall through to remote candidates
-  }
-
-  const remote = await readFromServerCandidates({
-    serverCandidates: args.serverCandidates,
-    readRemote: (serverUrl) => args.readRemote(serverUrl, args.dbKey),
-  });
-  if (args.cacheRemote) {
-    await args.cacheRemote(remote.value, remote.serverUrl);
-  }
-
-  return {
-    value: remote.value,
-    source: "remote-cache",
-    serverUrl: remote.serverUrl,
-  };
-}
-
-export async function readRecordWithCandidates<T>(args: {
-  db: LocalReadableDb;
-  dbKey: string;
-  serverCandidates: string[];
-  readRemote: (serverUrl: string, dbKey: string) => Promise<T>;
-  cacheRemote?: (value: T, serverUrl: string) => unknown | Promise<unknown>;
-  isReadableLocal?: (value: unknown) => value is T;
-}) {
-  const result = await readThroughRecord(args);
-  return result.value;
-}
-
-export async function readThroughList<T>(args: {
-  readLocal: () => Promise<T[]>;
-  readRemote: () => Promise<T[]>;
-  isEmpty?: (items: T[]) => boolean;
-}): Promise<{ items: T[]; source: HybridReadSource }> {
-  try {
-    const items = await args.readLocal();
-    const isEmpty = args.isEmpty ?? ((values: T[]) => values.length === 0);
-    if (!isEmpty(items)) {
-      return {
-        items,
-        source: "local-cache",
-      };
-    }
-  } catch {
-    // local cache unavailable; fall through to remote
-  }
-
-  return {
-    items: await args.readRemote(),
-    source: "remote-cache",
-  };
-}