@dench.com/cli 0.3.8 → 0.4.1

package/chat.ts

@@ -1,11 +1,12 @@
 /**
- * `dench chat <subcommand>` — CLI surface for browsing past chat threads
- * in the user's workspace.
+ * `dench chat <subcommand>` — CLI surface for browsing and managing
+ * past chat threads in the user's workspace.
  *
  * Mirrors the `dench crm` pattern: a thin command dispatcher on top of
- * Convex public queries (`functions/chat:listPastChats`,
- * `searchPastChats`, `readPastChat`) which themselves enforce the
- * "own + shared in this org" visibility rule.
+ * Convex public queries/mutations (`functions/chat:listPastChats`,
+ * `searchPastChats`, `readPastChat`, `renameThreads`, `deleteThreads`)
+ * which themselves enforce the "own + shared in this org" visibility
+ * rule (`requireThreadAccess`).
  *
  * Auth: every call forwards a single bearer token via `sessionToken`
  * (either a `dch_agent_*` agent session minted by `dench login` or a
@@ -16,9 +17,13 @@
  * inside a sandbox without extra flags.
  *
  * Subcommands:
- *   chat list   [--query <substr>] [--limit N] [--include-archived]
- *   chat search <query>            [--limit N] [--include-current]
- *   chat read   <thread-id>        [--limit N]
+ *   chat list    [--query <substr>] [--limit N] [--include-archived]
+ *   chat search  <query>            [--limit N] [--include-current]
+ *   chat read    <thread-id>        [--limit N]
+ *   chat rename  <thread-id> <new-title>           # single rename
+ *   chat rename  --from-stdin                       # batch via JSON {items:[...]}
+ *   chat delete  <thread-id> [<thread-id>...]      # 1–25 ids, --yes to skip prompt
+ *   chat delete  --ids id1,id2,id3                  # comma-separated form
  */
 import type { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
@@ -67,6 +72,12 @@ const api = {
   readPastChat: makeFunctionReference<"query">(
     "functions/chat:readPastChat",
   ),
+  renameThreads: makeFunctionReference<"mutation">(
+    "functions/chat:renameThreads",
+  ),
+  deleteThreads: makeFunctionReference<"mutation">(
+    "functions/chat:deleteThreads",
+  ),
 };
 
 function commonArgs(ctx: ChatCliContext) {
@@ -84,6 +95,14 @@ async function callQuery(
   return ctx.convex.query(fn, { ...args, ...commonArgs(ctx) } as never);
 }
 
+async function callMutation(
+  ctx: ChatCliContext,
+  fn: Parameters<ConvexHttpClient["mutation"]>[0],
+  args: Record<string, unknown> = {},
+): Promise<unknown> {
+  return ctx.convex.mutation(fn, { ...args, ...commonArgs(ctx) } as never);
+}
+
 function out(ctx: ChatCliContext, value: unknown): void {
   if (ctx.jsonOutput) {
     console.log(JSON.stringify(value, null, 2));
@@ -108,6 +127,19 @@ Full-text search across past chat messages (own + shared):
 Read messages from a specific past chat thread:
   dench chat read <thread-id> [--limit N] [--json]
 
+Rename one or more past chat threads (own + shared):
+  dench chat rename <thread-id> <new-title> [--json]
+  dench chat rename --from-stdin [--json]
+    Reads JSON {"items":[{"threadId":"...","title":"..."}, ...]} from stdin.
+    Up to 50 items per call. Titles are trimmed and clamped to 200 chars.
+
+PERMANENTLY delete one or more past chat threads (and all their messages):
+  dench chat delete <thread-id> [<thread-id>...] [--yes] [--json]
+  dench chat delete --ids id1,id2,id3 [--yes] [--json]
+    Up to 25 ids per call. IRREVERSIBLE — the messages are removed too.
+    Without --yes, the CLI prompts for confirmation when stdin is a TTY.
+    In non-interactive contexts (sandboxes, scripts), --yes is required.
+
 Spawn a new chat-turn workflow (same agent loop as the web UI):
   dench chat new "<prompt>" [--model <m>] [--file-context <path>] [--visibility private|shared] [--title T] [--yolo] [--follow] [--json]
   dench chat send <thread-id> "<message>" [--model <m>] [--yolo] [--follow] [--json]
@@ -163,6 +195,11 @@ export async function runChatCommand(opts: {
       return await runChatReadCommand(ctx);
     case "tree":
       return await runChatTreeCommand(ctx);
+    case "rename":
+      return await runChatRenameCommand(ctx);
+    case "delete":
+    case "rm":
+      return await runChatDeleteCommand(ctx);
     default:
       throw new ChatCliError(`Unknown chat subcommand: ${subcommand}`);
   }
@@ -222,6 +259,176 @@ async function runChatReadCommand(ctx: ChatCliContext): Promise<void> {
   );
 }
 
+async function readStdin(): Promise<string> {
+  if (process.stdin.isTTY) {
+    throw new ChatCliError(
+      "--from-stdin requires JSON piped on stdin (got TTY).",
+    );
+  }
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin as AsyncIterable<Buffer>) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+async function runChatRenameCommand(ctx: ChatCliContext): Promise<void> {
+  const fromStdin = hasFlag(ctx.args, "--from-stdin");
+  let items: Array<{ threadId: string; title: string }>;
+  if (fromStdin) {
+    const raw = (await readStdin()).trim();
+    if (!raw) {
+      throw new ChatCliError(
+        'Empty --from-stdin payload; expected {"items":[...]}.',
+      );
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (error) {
+      throw new ChatCliError(
+        `Invalid JSON on stdin: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+    if (
+      !parsed ||
+      typeof parsed !== "object" ||
+      !Array.isArray((parsed as { items?: unknown }).items)
+    ) {
+      throw new ChatCliError(
+        'Stdin JSON must be {"items":[{"threadId":"...","title":"..."}]}.',
+      );
+    }
+    const rawItems = (parsed as { items: unknown[] }).items;
+    items = rawItems.map((entry, index) => {
+      if (
+        !entry ||
+        typeof entry !== "object" ||
+        typeof (entry as { threadId?: unknown }).threadId !== "string" ||
+        typeof (entry as { title?: unknown }).title !== "string"
+      ) {
+        throw new ChatCliError(
+          `items[${index}] must be { threadId: string, title: string }.`,
+        );
+      }
+      const item = entry as { threadId: string; title: string };
+      if (!item.threadId.trim()) {
+        throw new ChatCliError(`items[${index}].threadId is empty.`);
+      }
+      if (!item.title.trim()) {
+        throw new ChatCliError(`items[${index}].title is empty.`);
+      }
+      return { threadId: item.threadId.trim(), title: item.title };
+    });
+  } else {
+    const threadId = shift(ctx.args, "thread id").trim();
+    const titleParts: string[] = [];
+    while (ctx.args.length > 0) {
+      const next = ctx.args.shift();
+      if (next === undefined) break;
+      if (next.startsWith("--")) {
+        ctx.args.unshift(next);
+        break;
+      }
+      titleParts.push(next);
+    }
+    const title = titleParts.join(" ").trim();
+    if (!title) {
+      throw new ChatCliError(
+        "Usage: dench chat rename <thread-id> <new-title>",
+      );
+    }
+    items = [{ threadId, title }];
+  }
+  if (items.length === 0) {
+    throw new ChatCliError("Nothing to rename.");
+  }
+  if (items.length > 50) {
+    throw new ChatCliError(
+      `Too many items (${items.length}); the server caps each call at 50.`,
+    );
+  }
+  out(ctx, await callMutation(ctx, api.renameThreads, { items }));
+}
+
+async function promptYesNo(question: string): Promise<boolean> {
+  if (!process.stdin.isTTY) return false;
+  process.stdout.write(`${question} [y/N] `);
+  return new Promise<boolean>((resolve) => {
+    const onData = (chunk: Buffer) => {
+      const answer = chunk.toString("utf8").trim().toLowerCase();
+      cleanup();
+      resolve(answer === "y" || answer === "yes");
+    };
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      try {
+        process.stdin.pause();
+      } catch {
+        // ignore: stdin may already be closed.
+      }
+    };
+    process.stdin.resume();
+    process.stdin.once("data", onData);
+  });
+}
+
+async function runChatDeleteCommand(ctx: ChatCliContext): Promise<void> {
+  const idsFlag = getFlag(ctx.args, "--ids");
+  const skipConfirm = hasFlag(ctx.args, "--yes") || hasFlag(ctx.args, "-y");
+  const collected: string[] = [];
+  if (idsFlag) {
+    for (const part of idsFlag.split(",")) {
+      const trimmed = part.trim();
+      if (trimmed) collected.push(trimmed);
+    }
+  }
+  while (ctx.args.length > 0) {
+    const next = ctx.args.shift();
+    if (next === undefined) break;
+    if (next.startsWith("--")) {
+      ctx.args.unshift(next);
+      break;
+    }
+    if (next.trim()) collected.push(next.trim());
+  }
+  const seen = new Set<string>();
+  const threadIds = collected.filter((id) => {
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+  if (threadIds.length === 0) {
+    throw new ChatCliError(
+      "Usage: dench chat delete <thread-id> [<thread-id>...]  (or --ids id1,id2,...)",
+    );
+  }
+  if (threadIds.length > 25) {
+    throw new ChatCliError(
+      `Too many thread ids (${threadIds.length}); the server caps each call at 25. Run multiple invocations.`,
+    );
+  }
+  if (!skipConfirm) {
+    if (!process.stdin.isTTY) {
+      throw new ChatCliError(
+        "Refusing to delete without --yes in non-interactive mode (no TTY).",
+      );
+    }
+    const ok = await promptYesNo(
+      `PERMANENTLY delete ${threadIds.length} chat${
+        threadIds.length === 1 ? "" : "s"
+      } and all their messages?`,
+    );
+    if (!ok) {
+      console.error("Aborted.");
+      return;
+    }
+  }
+  out(ctx, await callMutation(ctx, api.deleteThreads, { threadIds }));
+}
+
 /**
  * `dench chat tree [<root-thread-id>] [--limit N] [--json]` — print the
  * parent-child chat thread hierarchy rooted at the given thread (or

package/cron.ts

@@ -5,10 +5,12 @@
  * Each cron is a row in the Convex `triggers` table that, when due,
  * spawns a fresh chat thread (the `target: "chat_turn"` path — new
  * default) running in YOLO mode and seeded with the cron's prompt as
- * the first user message. The Vercel cron dispatcher (`/api/cron/dispatch`,
- * scheduled via `vercel.json` at every minute) walks the
- * `by_enabled_nextFireAt` index, claims due rows, and fires the
- * workflow.
+ * the first user message. Scheduling is owned by the
+ * `@convex-dev/crons` component: each create/update/enable mutation
+ * registers a component cron under name=triggerId; the component fires
+ * `internal.functions.triggersNode.fireDenchTrigger` at the precise
+ * scheduled time, which then POSTs to `/api/runs/spawn-{chat,child}`
+ * to start the workflow.
  *
  * Auth: prefers the unified Dench API key from `DENCH_API_KEY`
  * (sandbox envVar baked at create time). Falls back to `dench login`
@@ -504,6 +506,8 @@ async function runHistory(ctx: CronCliContext): Promise<void> {
 
 function cronHelp(): void {
   console.log(`Usage: dench cron <subcommand>
+       dench routine <subcommand>     (alias)
+       dench routines <subcommand>    (alias)
 
 Browse:
   dench cron list [--enabled-only] [--json]