@ccmsg/cli 0.8.1 → 0.9.0

package/src/transcript/items/render.ts

@@ -4,7 +4,7 @@ import { fields, type Item } from "./item.ts";
  *
  * A type is drawn by one function, the way the same type is drawn by one
  * component where the destination is a screen instead of text. What the two
- * share is the classification; how a `tool:Bash` reads is the drawing's own
+ * share is the classification; how a `tool.Bash` reads is the drawing's own
  * business, and neither side carries the other's.
  *
  * A type nobody wrote a drawing for is still drawn. The generic shape says the
@@ -33,8 +33,8 @@ const EMPTY: readonly string[] = [];
 /** The drawing for one item, whatever its type. */
 export function fragment(item: Item): Fragment {
   const type = item.type;
-  if (type.startsWith("tool:")) {
-    const name = type.slice("tool:".length);
+  if (type.startsWith("tool.")) {
+    const name = type.slice("tool.".length);
     const result = isResult(item);
     const draw = (result ? RESULTS : USES)[name];
     if (draw !== undefined) return draw(item);
@@ -44,8 +44,8 @@ export function fragment(item: Item): Fragment {
   }
   const draw = ITEMS[type];
   if (draw !== undefined) return draw(item);
-  if (type.startsWith("hook:")) return hook(item);
-  if (type.startsWith("system:attachment:"))
+  if (type.startsWith("hook.")) return hook(item);
+  if (type.startsWith("system.attachment."))
     return { head: "", body: summary(fields(item)["attachment"]) };
   return { head: "", body: summary(own(item)) };
 }
@@ -60,16 +60,16 @@ function isResult(item: Item): boolean {
  * kept as they were written: a dump is read to find out what somebody actually
  * wrote, and a reader who wants less asks for less. */
 const SAID: readonly string[] = [
-  "message:user:in",
-  "message:user:out",
+  "message.user.in",
+  "message.user.out",
   "thinking",
-  "system:compact",
+  "system.compact",
 ];
 
 const ITEMS: Record<string, Draw> = {
   ...Object.fromEntries(SAID.map((type) => [type, said])),
 
-  "message:sub:out": (item) => ({
+  "message.sub.out": (item) => ({
     head: words(
       field(item, "agent_id", "agent="),
       field(item, "subagent_type", "type="),
@@ -79,7 +79,7 @@ const ITEMS: Record<string, Draw> = {
     body: lines(str(item, "prompt")),
   }),
 
-  "message:sub:in": (item) => ({
+  "message.sub.in": (item) => ({
     head: words(
       field(item, "agent_id", "agent="),
       field(item, "status", "status="),
@@ -91,17 +91,17 @@ const ITEMS: Record<string, Draw> = {
   // The one above and the ones alongside. A name is on the heading wherever
   // the record gave one — an answer handed back as prose names nobody, and a
   // heading that invented a name for it would say more than the file does.
-  "message:parent:in": (item) => ({
+  "message.parent.in": (item) => ({
     head: words(field(item, "harness_name", "from="), mid(item)),
     body: lines(str(item, "text")),
   }),
 
-  "message:parent:out": (item) => ({
+  "message.parent.out": (item) => ({
     head: words(field(item, "harness_name", "to="), str(item, "summary")),
     body: lines(str(item, "text")),
   }),
 
-  "message:team:out": (item) => ({
+  "message.team.out": (item) => ({
     head: words(
       field(item, "harness_name", "to="),
       field(item, "agent_id", "agent="),
@@ -115,7 +115,7 @@ const ITEMS: Record<string, Draw> = {
   // Both halves of a teammate's correspondence arrive under one type: a letter
   // it wrote, which names who wrote it, and its run ending, which names how it
   // ended. Each heading says whichever of those the item carried.
-  "message:team:in": (item) => ({
+  "message.team.in": (item) => ({
     head: words(
       field(item, "harness_name", "from="),
       mid(item),
@@ -126,12 +126,12 @@ const ITEMS: Record<string, Draw> = {
     body: lines(str(item, "text")),
   }),
 
-  "message:session:out": (item) => ({
+  "message.session.out": (item) => ({
     head: words(field(item, "to", "to="), field(item, "reply_to", "reply_to="), mid(item)),
     body: lines(str(item, "text")),
   }),
 
-  "message:session:in": (item) => ({
+  "message.session.in": (item) => ({
     head: words(field(item, "from", "from="), mid(item)),
     body: lines(str(item, "text")),
   }),
@@ -140,15 +140,15 @@ const ITEMS: Record<string, Draw> = {
   // voice. Both are why a conversation jumps rather than part of it, so they
   // are a line each and the line names what happened. Everything the record
   // held is in the JSON dump beside this one, addressable by the id shown.
-  "notice:slash": (item) => ({
+  "notice.slash": (item) => ({
     head: words(`/${str(item, "command") ?? ""}`, str(item, "args"), first(str(item, "stdout"))),
     body: EMPTY,
   }),
-  "notice:interrupt": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
-  "system:api-error": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
-  "system:caveat": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
-  "system:resume": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
-  "system:task": (item) => ({
+  "notice.interrupt": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
+  "system.api.error": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
+  "system.caveat": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
+  "system.resume": (item) => ({ head: first(str(item, "text")) ?? "", body: EMPTY }),
+  "system.task": (item) => ({
     head: words(
       field(item, "task_id", "task="),
       field(item, "event", "event="),
@@ -156,7 +156,7 @@ const ITEMS: Record<string, Draw> = {
     ),
     body: EMPTY,
   }),
-  "system:unknown": (item) => ({ head: "", body: summary(fields(item)["record"]) }),
+  "system.unknown": (item) => ({ head: "", body: summary(fields(item)["record"]) }),
 };
 
 function said(item: Item): Fragment {
@@ -214,7 +214,7 @@ const USES: Record<string, Draw> = {
   Glob: pattern,
   WebFetch: (item) => ({ head: words(str(item, "url"), str(item, "prompt")), body: EMPTY }),
   WebSearch: (item) => ({ head: field(item, "query", "query=") ?? "", body: EMPTY }),
-  // The brief itself is the `message:sub:out` beside this call, so the call
+  // The brief itself is the `message.sub.out` beside this call, so the call
   // says which agent was started and leaves the words to the message.
   Agent: (item) => ({
     head: words(

package/src/transcript/items/select.ts

@@ -11,8 +11,8 @@ import type { Item } from "./item.ts";
  * shape a person actually reaches for — every tool but the reads, the whole
  * conversation but not the thinking.
  *
- * A prefix matches at segment boundaries, so `tool` reaches `tool:Bash` and
- * `message:user` reaches both directions, while `notice` never reaches a type
+ * A prefix matches at segment boundaries, so `tool` reaches `tool.Bash` and
+ * `message.user` reaches both directions, while `notice` never reaches a type
  * that merely starts with those letters. */
 
 /** What a dump keeps when nobody said: every family there is, less the
@@ -29,7 +29,7 @@ const DEFAULT_TYPES = [
   "notice",
   "system",
   "hook",
-  "-system:attachment",
+  "-system.attachment",
 ];
 
 export interface Selection {
@@ -55,7 +55,7 @@ export interface Ask {
 }
 
 const NO_THINKING = ["-thinking"];
-const NO_AGENT = ["-message:sub", "-tool:Agent"];
+const NO_AGENT = ["-message.sub", "-tool.Agent"];
 
 export function selection(ask: Ask, presets: readonly DumpPreset[]): Selection {
   const asked = [...(ask.preset?.opts.types ?? []), ...(ask.types ?? [])];
@@ -94,7 +94,7 @@ function decide(type: string, elements: readonly string[]): boolean {
 }
 
 function reaches(name: string, type: string): boolean {
-  return type === name || type.startsWith(`${name}:`);
+  return type === name || type.startsWith(`${name}.`);
 }
 
 /** A preset named in a selection, put where it was named.

package/src/transcript/transcripts.ts

@@ -4,7 +4,7 @@ import { NO_FACTS, type TranscriptFacts, TranscriptFold } from "./fold.ts";
 import { Classification, type Item, positioned } from "./items/index.ts";
 import { type Appended, TranscriptTail } from "./tail.ts";
 
-/** How many items a subscription to `transcript_items:<sid>` opens with.
+/** How many items a subscription to `transcript.items:<sid>` opens with.
  *
  * The tail of the same megabyte the fold is seeded from, bounded by a count
  * because that read is bounded by bytes: a file of many small records would
@@ -17,7 +17,7 @@ export const ITEMS_SNAPSHOT = 200;
 /** Which of the two topics a name is. Both are fed by one tail, so the
  * resource is entered by either name and answers each in its own vocabulary. */
 function isItems(topic: string): boolean {
-  return topic.startsWith("transcript_items:");
+  return topic.startsWith("transcript.items:");
 }
 
 export interface TranscriptsDeps {
@@ -183,7 +183,7 @@ export class Transcripts implements UpstreamResource {
     // A record still being written was not read, so there is nothing to say
     // about it yet; a chunk whose records were all the interface's own
     // bookkeeping says nothing either.
-    if (items.length > 0) this.deps.publish(`transcript_items:${sid}`, { sid, items });
+    if (items.length > 0) this.deps.publish(`transcript.items:${sid}`, { sid, items });
     if (changed) this.deps.onFacts(sid);
   }
 

package/src/translate/translate.ts

@@ -121,7 +121,7 @@ function read(line: string, id: string, expected: number): TranslateResult[] {
 
 export function translateHandlers(translate: Translate) {
   return {
-    translate_run: (input: HandlerInput): Promise<TranslateRunResult> =>
+    "translate.run": (input: HandlerInput): Promise<TranslateRunResult> =>
       translate.run(input.args as unknown as TranslateRunArgs),
   };
 }

package/src/transport/driver.ts

@@ -1,4 +1,4 @@
-import { MAX_FRAME_BYTES, type OpName, type Role, type Sid } from "@ccmsg/protocol";
+import { helloRole, isHelloOp, MAX_FRAME_BYTES, type Sid } from "@ccmsg/protocol";
 import { type DispatchResult, failure, type Requester } from "../dispatch/index.ts";
 import type { Conn } from "./conn.ts";
 
@@ -8,10 +8,9 @@ export interface FrameHandler {
   (frame: unknown, conn: Requester): Promise<DispatchResult>;
 }
 
-/** The op whose reply settles the connection's identity. Transport knows this
- * one op name because binding the identity is its job (daemon-v2 §3.1); every
- * other op is opaque to it. */
-const HELLO = "hello" satisfies OpName;
+/** The ops whose reply settles the connection's identity. Transport knows these
+ * three op names because binding the identity is its job (daemon-v2 §3.1);
+ * every other op is opaque to it. */
 
 /** Drive one connection: a line in, a frame answered on the same connection.
  *
@@ -67,19 +66,22 @@ export function createDriver(conn: Conn, handle: FrameHandler) {
   };
 }
 
-/** Bind role and sid at the moment the `hello` reply goes out.
+/** Bind role and sid at the moment a greeting's reply goes out.
  *
- * The frame is safe to read because dispatch only answers `reply` after the
- * op's own schema accepted it, so `role` is a role and `sid` — required of a
- * session and absent otherwise — is a sid. */
+ * The role is read from the op that carried the greeting rather than from a
+ * field of it: there is one op per role, so the name is the only place the
+ * role is said. The frame is safe to read because dispatch only answers
+ * `reply` after the op's own schema accepted it, so `sid` — asked for by
+ * `hello.session` and by neither of the others — is a sid. */
 function settleIfHello(conn: Conn, frame: unknown, result: DispatchResult): void {
   if (result.kind !== "reply") return;
   const fields = frame as Record<string, unknown>;
-  if (fields["op"] !== HELLO) return;
+  const op = fields["op"];
+  if (typeof op !== "string" || !isHelloOp(op)) return;
   const sid = fields["sid"];
   conn.settle({
     state: "settled",
-    role: fields["role"] as Role,
+    role: helloRole(op),
     ...(typeof sid === "string" ? { sid: sid as Sid } : {}),
   });
 }

package/src/upstream/gateway.ts

@@ -95,13 +95,13 @@ export function gatewayHandlers(setup: GatewaySetup, fetcher?: typeof fetch) {
     ...(usageUrl === undefined
       ? {}
       : {
-          llm_usage_read: (input: HandlerInput): Promise<LlmUsageReadResult> =>
+          "llm.usage.read": (input: HandlerInput): Promise<LlmUsageReadResult> =>
             readUsage({ url: usageUrl, ...call }, input.args as unknown as LlmUsageReadArgs),
         }),
     ...(statsUrl === undefined
       ? {}
       : {
-          llm_stats_read: (input: HandlerInput): Promise<LlmStatsReadResult> =>
+          "llm.stats.read": (input: HandlerInput): Promise<LlmStatsReadResult> =>
             readStats({ url: statsUrl, ...call }, input.args as unknown as LlmStatsReadArgs),
         }),
   };
@@ -165,7 +165,7 @@ export class Gateway {
           };
   }
 
-  /** The resource behind `llm_status`. A stand-in that states nothing when the
+  /** The resource behind `llm.status`. A stand-in that states nothing when the
    * gateway's address is not configured — the topic's capability is absent
    * then, so nothing reaches it, and the attachment stays unconditional. */
   get statusResource(): UpstreamResource {

package/src/upstream/requests.ts

@@ -156,7 +156,7 @@ export class LlmRequests implements UpstreamResource {
   }
 
   private publish(): void {
-    this.deps.publish("llm_requests", this.entries());
+    this.deps.publish("llm.requests", this.entries());
   }
 
   /** Note the session was seen, and say what that moved.

package/src/upstream/status.ts

@@ -141,7 +141,7 @@ export class LlmStatus implements UpstreamResource {
       return;
     }
     this.#report = report;
-    this.deps.publish("llm_status", report);
+    this.deps.publish("llm.status", report);
   }
 }
 

package/src/version.ts

@@ -3,6 +3,6 @@ import { version } from "../package.json";
 /** This build of ccmsg, taken from the package it is published as so that the
  * binary, the CLI and the plugin it installs never name three versions.
  *
- * It is also the daemon build `hello` and `instance_ping` report, which is what
+ * It is also the daemon build `hello` and `instance.ping` report, which is what
  * makes "what a client is told" and "what was released" the same number. */
 export const VERSION: string = version;