nolo-cli 0.1.41 → 0.1.43

package/cli/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/cli/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/cli/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/cli/internalCommandEntries.ts

@@ -1,6 +1,8 @@
 import { getAgentInternalCommandEntries } from "./agentInternalCommandEntries";
 import { getDialogInternalCommandEntries } from "./dialogInternalCommandEntries";
+import { getDocInternalCommandEntries } from "./docInternalCommandEntries";
 import type { CommandEntry } from "./cliCommandTypes";
+import { getMemoryInternalCommandEntries } from "./memoryInternalCommandEntries";
 import { getSystemInternalCommandEntries } from "./systemInternalCommandEntries";
 import { getWorkflowInternalCommandEntries } from "./workflowInternalCommandEntries";
 
@@ -8,6 +10,8 @@ export function getInternalCommandEntries(renderHelpText: () => string): Command
   return [
     ...getAgentInternalCommandEntries(),
     ...getDialogInternalCommandEntries(),
+    ...getDocInternalCommandEntries(),
+    ...getMemoryInternalCommandEntries(),
     ...getWorkflowInternalCommandEntries(),
     ...getSystemInternalCommandEntries(renderHelpText),
   ];

package/cli/machineCommands.ts

@@ -132,50 +132,34 @@ function detectLaunchableMachineInfo() {
   return detectMachineInfo({ probeLaunchable: true });
 }
 
-function inferTaskRunRole(agentKey: string, agentConfig: any) {
-  const haystack = [
-    agentKey,
-    agentConfig?.name,
-    agentConfig?.prompt,
-  ].filter(Boolean).join("\n").toLowerCase();
-  if (haystack.includes("frontend") || haystack.includes("前端")) return "frontend";
-  if (haystack.includes("fullstack") || haystack.includes("全栈")) return "fullstack";
-  if (haystack.includes("review") || haystack.includes("审查")) return "reviewer";
-  if (haystack.includes("project-manager") || haystack.includes("项目经理")) return "pm";
-  return "codex";
+function findTaskRowSubjectRef(runtimeContext: any) {
+  const subjectRefs = Array.isArray(runtimeContext?.subjectRefs) ? runtimeContext.subjectRefs : [];
+  for (const ref of subjectRefs) {
+    if (!ref || typeof ref !== "object" || Array.isArray(ref)) continue;
+    if (ref.kind !== "table-row") continue;
+    const id = typeof ref.id === "string" ? ref.id.trim() : "";
+    if (id) return id;
+  }
+  return "";
 }
 
-function buildTaskRunBridgePrompt(args: {
+function buildTaskEvidencePrompt(args: {
   agentKey: string;
   agentConfig: any;
   runtimeContext: any;
 }) {
-  const taskRun = args.runtimeContext?.taskRun;
-  const rowDbKey = typeof taskRun?.rowDbKey === "string" ? taskRun.rowDbKey.trim() : "";
+  const rowDbKey = findTaskRowSubjectRef(args.runtimeContext);
   if (!rowDbKey) return "";
-  const workItemId = typeof taskRun?.workItemId === "string" ? taskRun.workItemId.trim() : "";
-  const role = inferTaskRunRole(args.agentKey, args.agentConfig);
   return [
-    "--- Nolo task-run tool bridge ---",
+    "--- Nolo task evidence context ---",
     "This CLI runtime does not receive server-side function tools directly.",
-    "Use the local task-run bridge command for durable task state writes. Do not edit meta.taskRun with table or database commands.",
+    "Use the task row subjectRef and linked dialog/activity evidence as the durable task context.",
     "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
     "Release boundary: after review passes, AI/reviewer/Codex may advance alpha for verification. Do not merge, push, or release main/release unless the human owner explicitly authorizes it in the current task context.",
-    "Cost boundary: read taskRun.control from context. Prefer low-cost/free-window models for routine work, and reserve Codex for supervision, quality gates, complex unblocking, and main/release decisions.",
-    "Handoff context: start from read-context, then inspect existing refs such as workItems.dialogIds, workItems.outcome, review.dialogId, activityRefs, agentRuns.dialogId/resultSummary, and artifactRefs. Use dialog read/search for exact evidence; do not infer completion from handoff text alone.",
-    `Read context: bun packages/cli/index.ts task-run read-context --row-dbkey ${JSON.stringify(rowDbKey)}`,
-    ...(workItemId
-      ? [
-          `Claim work item: bun packages/cli/index.ts task-run claim-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --agent-key ${JSON.stringify(args.agentKey)} --role ${role}`,
-          `Set blocker: bun packages/cli/index.ts task-run set-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --layer tool --code <CODE> --message <MESSAGE>`,
-          `Clear resolved blocker: bun packages/cli/index.ts task-run clear-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --blocker-id <BLOCKER_ID>`,
-          `Submit outcome: bun packages/cli/index.ts task-run submit-outcome --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
-          `Request review: bun packages/cli/index.ts task-run request-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --reviewer-agent-key <AGENT_KEY> --message <MESSAGE>`,
-          `Record review: bun packages/cli/index.ts task-run record-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --review-status <passed|needs_changes|blocked> --reviewer-agent-key ${JSON.stringify(args.agentKey)} --findings <FINDINGS>`,
-          `Close work item: bun packages/cli/index.ts task-run close-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
-        ]
-      : []),
-    "If a bridge command fails, report the exact command and error.",
+    "Handoff context: inspect activityRefs/latestActivityRef, dialog checkpoints, artifacts, commits, and test evidence. Use dialog read/search for exact evidence; do not infer completion from handoff text alone.",
+    `Read task row: bun packages/cli/index.ts table query --table meta-0e95801d90-NOLOTASKBOARD --row ${JSON.stringify(rowDbKey)} --include-activity --output json`,
+    "Then read linked activity dialog ids with: bun packages/cli/index.ts dialog read <dialogId>",
+    "Report progress, blockers, worktree, branch, commit/diff, tests, and unverified items in the dialog.",
   ].join("\n");
 }
 
@@ -186,7 +170,7 @@ function buildConnectorCliPrompt(agentConfig: any, userInput: string, bridgeArgs
   const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
   return [
     typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
-    bridgeArgs ? buildTaskRunBridgePrompt({
+    bridgeArgs ? buildTaskEvidencePrompt({
       agentKey: bridgeArgs.agentKey,
       agentConfig,
       runtimeContext: bridgeArgs.runtimeContext,

package/cli/memoryCommands.ts

@@ -0,0 +1,253 @@
+import type { AgentCommandDeps } from "./agentCommandSupport";
+import {
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+
+const VALUE_FLAGS = new Set([
+  "--facet",
+  "--id",
+  "--ids",
+  "--kind",
+  "--limit",
+  "--pattern-prefix",
+  "--server",
+  "--server-url",
+  "--source-dialog",
+  "--subject",
+  "--subject-id",
+  "--subject-type",
+  "--tag",
+  "--token",
+]);
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function printMemoryDeleteUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo memory delete --source-dialog <dialogId> --yes [--json]
+  nolo memory delete --tag <tag> --kind <kind> --yes
+  nolo memory delete --pattern-prefix <prefix> --limit <n> --yes
+
+Options:
+  --id <memoryId>            Delete a specific memory id. Repeatable.
+  --ids <a,b,c>              Delete specific memory ids.
+  --source-dialog <dialogId> Delete memories created from one dialog.
+  --tag <tag>                Require a tag. Repeatable.
+  --kind <kind>              Filter episodic / semantic / procedural. Repeatable.
+  --facet <facet>            Filter preference / tension / unfinished / goal / style. Repeatable.
+  --subject-type <type>      Filter user / agent / space / project / system.
+  --subject <subjectId>      Filter subjectId.
+  --pattern-prefix <prefix>  Filter patternKey prefix.
+  --limit <n>                Maximum memories to delete.
+  --yes                      Actually delete. Without this, command is a dry-run.
+  --json                     Print machine-readable JSON.
+  --server <url>             Prefer this server and include known Nolo peers.
+  --token <jwt>              Override AUTH_TOKEN.
+
+At least one filter is required; this command will not delete all memory implicitly.
+`);
+}
+
+function readRepeated(args: string[], flag: string) {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== flag) continue;
+    const value = args[index + 1];
+    if (typeof value === "string" && value.trim()) values.push(value.trim());
+  }
+  return values;
+}
+
+function readCsvValues(args: string[], flag: string) {
+  const raw = readRepeated(args, flag).join(",");
+  return raw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+function readLimit(args: string[]) {
+  const raw = readOption(args, "--limit");
+  if (!raw) return undefined;
+  if (!/^\d+$/.test(raw)) throw new Error(`invalid --limit: ${raw}`);
+  const parsed = Number(raw);
+  return parsed > 0 ? parsed : undefined;
+}
+
+function assertNoUnknownFlags(args: string[]) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (!value.startsWith("-")) continue;
+    if (value === "--help" || value === "-h" || value === "--yes" || value === "--json") continue;
+    if (VALUE_FLAGS.has(value)) {
+      index += 1;
+      continue;
+    }
+    throw new Error(`unknown option: ${value}`);
+  }
+}
+
+function buildDeleteBody(args: string[]) {
+  const ids = [...readRepeated(args, "--id"), ...readCsvValues(args, "--ids")];
+  const kinds = readRepeated(args, "--kind");
+  const facets = readRepeated(args, "--facet");
+  const tags = readRepeated(args, "--tag");
+  const sourceDialogId = readOption(args, "--source-dialog")?.trim();
+  const subjectType = readOption(args, "--subject-type")?.trim();
+  const subjectId = (readOption(args, "--subject") ?? readOption(args, "--subject-id"))?.trim();
+  const patternKeyPrefix = readOption(args, "--pattern-prefix")?.trim();
+  const limit = readLimit(args);
+
+  const body: Record<string, unknown> = {};
+  if (ids.length) body.ids = [...new Set(ids)];
+  if (kinds.length) body.kinds = [...new Set(kinds)];
+  if (facets.length) body.facets = [...new Set(facets)];
+  if (tags.length) body.tags = [...new Set(tags)];
+  if (sourceDialogId) body.sourceDialogId = sourceDialogId;
+  if (subjectType) body.subjectType = subjectType;
+  if (subjectId) body.subjectId = subjectId;
+  if (patternKeyPrefix) body.patternKeyPrefix = patternKeyPrefix;
+  if (typeof limit === "number") body.limit = limit;
+  return body;
+}
+
+function hasDeleteFilter(body: Record<string, unknown>) {
+  return Object.keys(body).some((key) => key !== "limit");
+}
+
+async function postMemoryDelete(args: {
+  authToken: string;
+  body: Record<string, unknown>;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/memory/delete`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(args.body),
+  });
+  const text = await res.text();
+  let payload: any = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { raw: text };
+  }
+  if (!res.ok || payload?.error) {
+    const message =
+      payload?.error?.message ??
+      payload?.message ??
+      payload?.error ??
+      `HTTP ${res.status}`;
+    throw new Error(`${message}`);
+  }
+  return payload;
+}
+
+export async function runMemoryDeleteCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printMemoryDeleteUsage(output);
+    return 0;
+  }
+
+  try {
+    assertNoUnknownFlags(args);
+    const authToken = resolveAuthToken(args, env);
+    if (!authToken) {
+      output.write("[nolo] memory delete requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+
+    const body = buildDeleteBody(args);
+    if (!hasDeleteFilter(body)) {
+      output.write("[nolo] memory delete requires at least one filter; use --help for examples.\n");
+      return 1;
+    }
+
+    const shouldDelete = hasFlag(args, "--yes");
+    const wantJson = hasFlag(args, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args, env);
+    const serverUrls = resolveServerCandidates(args, env, serverUrl);
+
+    if (!shouldDelete) {
+      const payload = {
+        dryRun: true,
+        deleted: false,
+        targetServers: serverUrls,
+        request: body,
+        nextStep: "rerun with --yes to delete matching memories",
+      };
+      if (wantJson) {
+        output.write(`${JSON.stringify(payload, null, 2)}\n`);
+      } else {
+        output.write("dryRun: true\n");
+        output.write(`targetServers: ${serverUrls.join(", ")}\n`);
+        output.write(`request: ${JSON.stringify(body)}\n`);
+        output.write("rerun with --yes to delete matching memories\n");
+      }
+      return 0;
+    }
+
+    const deleteResults = [];
+    for (const target of serverUrls) {
+      try {
+        const result = await postMemoryDelete({
+          authToken,
+          body,
+          fetchImpl,
+          serverUrl: target,
+        });
+        deleteResults.push({ serverUrl: target, ok: true, result });
+      } catch (error) {
+        deleteResults.push({
+          serverUrl: target,
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    const deletedCount = deleteResults.reduce(
+      (sum, item) => sum + (item.ok ? Number(item.result?.deletedCount ?? 0) : 0),
+      0
+    );
+    const payload = {
+      dryRun: false,
+      deleted: true,
+      deletedCount,
+      request: body,
+      targetServers: serverUrls,
+      deleteResults,
+    };
+    if (wantJson) {
+      output.write(`${JSON.stringify(payload, null, 2)}\n`);
+    } else {
+      output.write(`deletedCount: ${deletedCount}\n`);
+      for (const result of deleteResults) {
+        output.write(
+          result.ok
+            ? `${result.serverUrl}: ok deleted=${result.result?.deletedCount ?? 0}\n`
+            : `${result.serverUrl}: failed ${result.error}\n`
+        );
+      }
+    }
+    return deleteResults.some((result) => result.ok) ? 0 : 1;
+  } catch (error) {
+    output.write(`[nolo] memory delete failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}

package/cli/memoryInternalCommandEntries.ts

@@ -0,0 +1,9 @@
+import type { CommandEntry } from "./cliCommandTypes";
+import { createEnvCommand } from "./cliCommandFactories";
+import { runMemoryDeleteCommand } from "./memoryCommands";
+
+export function getMemoryInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["memory", "delete"], "Delete long-term memories by filter", runMemoryDeleteCommand),
+  ];
+}