@stigmer/cli 3.12.3 → 3.12.4

package/src/resources/skill.ts

@@ -8,10 +8,8 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 import { create } from "@bufbuild/protobuf";
-import { Code, ConnectError } from "@connectrpc/connect";
 import type { Skill } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
-import type { PushSkillRequest } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/io_pb";
-import { CreateSkillArtifactUploadUrlRequestSchema, PushSkillRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/io_pb";
+import { PushSkillRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/io_pb";
 import { GitProvenanceSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/status_pb";
 import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
 import { UpdateVisibilityInputSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
@@ -322,67 +320,10 @@ export function analyzeDryRun(dir: string, options: IgnoreOptions): DryRunAnalys
   return { stats, patternSources, sampleIgnored, sampleIncluded };
 }
 
-/**
- * Largest artifact pushed inline in the gRPC request (#675). The server's
- * transport cap is 10MB for the WHOLE message, so the artifact leaves 64KB
- * of headroom for the request envelope (org, tag, provenance, framing).
- * Mirrors the Go SDK's maxInlineArtifactBytes.
- */
-const MAX_INLINE_ARTIFACT_BYTES = 10 * 1024 * 1024 - 64 * 1024;
-
-/**
- * Push, routing the artifact by size (#675): small artifacts travel inline
- * in the request (one round trip, unchanged behavior); larger ones are
- * staged over HTTP via createArtifactUploadUrl — a capability URL, so no
- * auth header — and pushed by reference. The 100MB skill limit therefore
- * no longer collides with the 10MB gRPC message cap.
- */
-export async function pushRouted(client: Stigmer, request: PushSkillRequest): Promise<Skill> {
-  if (request.artifact.length <= MAX_INLINE_ARTIFACT_BYTES) {
-    return client.skill.push(request);
-  }
-
-  let minted;
-  try {
-    minted = await client.skill.createArtifactUploadUrl(
-      create(CreateSkillArtifactUploadUrlRequestSchema, {
-        org: request.org,
-        sizeBytes: BigInt(request.artifact.length),
-      }),
-    );
-  } catch (err) {
-    if (err instanceof ConnectError && err.code === Code.Unimplemented) {
-      // Pre-transfer-lane server: an artifact this size physically cannot
-      // travel inline. Say so instead of surfacing the raw transport error.
-      throw new UsageError(
-        `skill artifact is ${formatBytes(request.artifact.length)}, above the ~10MB gRPC message cap, ` +
-          "and this server does not support the HTTP artifact transfer lane.\n\n" +
-          "Upgrade stigmer-server to push skills of this size.",
-      );
-    }
-    throw err;
-  }
-
-  const resp = await fetch(minted.url, {
-    method: "PUT",
-    // Buffer keeps undici's BodyInit typing happy where a bare Uint8Array
-    // view does not (Node-only code path, so Buffer is always available).
-    body: Buffer.from(request.artifact),
-    headers: { "content-type": "application/zip" },
-  });
-  if (!resp.ok) {
-    const detail = (await resp.text().catch(() => "")).slice(0, 512).trim();
-    throw new Error(`skill artifact upload rejected with HTTP ${resp.status}${detail === "" ? "" : `: ${detail}`}`);
-  }
-
-  // Same request, artifact traveling by reference instead of by value.
-  const byRef = create(PushSkillRequestSchema, {
-    ...request,
-    artifact: new Uint8Array(0),
-    artifactUploadRef: minted.artifactUploadRef,
-  });
-  return client.skill.push(byRef);
-}
+// Size-routed push (#675) moved down into the SDK (stigmer#701): the
+// Stigmer client's `skill.push` routes large artifacts over the HTTP
+// transfer lane itself, so the CLI — like every other SDK consumer — just
+// calls push. See sdk/typescript/src/skill.ts (RoutedSkillClient).
 
 /** Push a skill from a local directory. Git provenance is auto-detected. */
 export async function pushSkill(
@@ -410,7 +351,7 @@ export async function pushSkill(
     message,
     gitProvenance: provenance,
   });
-  const response = await pushRouted(client, request);
+  const response = await client.skill.push(request);
   const applied = await applyDeclaredVisibility(client, response, visibility);
   return toResult(applied, name, message, stats.totalSize, visibility);
 }
@@ -452,7 +393,7 @@ export async function pushSkillFromClone(
     message: params.message,
     gitProvenance: provenance,
   });
-  const response = await pushRouted(client, request);
+  const response = await client.skill.push(request);
   const applied = await applyDeclaredVisibility(client, response, visibility);
   return toResult(applied, name, params.message, stats.totalSize, visibility);
 }
@@ -540,7 +481,7 @@ export async function pushSkillFromArchive(
   });
   // Size-routed like every other push path (#675): pre-packaged archives are
   // the release-pipeline lane, exactly where content-heavy skills come from.
-  const response = await pushRouted(client, request);
+  const response = await client.skill.push(request);
   const applied = await applyDeclaredVisibility(client, response, archive.meta.visibility);
   return toResult(applied, archive.meta.name, message, archive.totalSize, archive.meta.visibility);
 }

package/src/resources/stream/events.ts

@@ -1,17 +1,19 @@
 // The sealed event model for the headless snapshot differ.
 //
-// Mirrors Go's pkg/executiontui.Event family (events.go). The differ projects
-// each AgentExecution snapshot into a sequence of these discrete events; the
+// Inherited from the retired Go CLI's pkg/executiontui.Event family (deleted
+// with the TypeScript migration, PR #203). The differ projects each
+// AgentExecution snapshot into a sequence of these discrete events; the
 // NDJSON and plaintext renderers consume them. The Ink TTY path does NOT use
-// this model — it renders from full snapshots via @stigmer/react.
+// this model — it renders from full snapshots via @stigmer/ink.
 //
-// `kind` is the discriminant. The NDJSON renderer maps each kind to Go's exact
-// wire taxonomy (run_stream_json.go), so kinds are deliberately 1:1 with the Go
-// event types rather than the wire strings.
+// `kind` is the discriminant. The NDJSON renderer preserves the retired Go
+// CLI's exact wire taxonomy (its run_stream_json.go) — that output is a
+// machine contract consumers may parse — so kinds are deliberately 1:1 with
+// the original event types rather than the wire strings.
 
 import type { JsonObject } from "@bufbuild/protobuf";
 
-/** A tool call projected for rendering. Mirrors toolrender.ToolCallInfo. */
+/** A tool call projected for rendering. Shape inherited from the retired Go CLI's toolrender.ToolCallInfo. */
 export interface ToolCallInfo {
   readonly id: string;
   readonly name: string;

package/src/resources/stream/render-plaintext.test.ts

@@ -39,6 +39,57 @@ describe("PlaintextRenderer", () => {
     expect(status).toContain("✗ shell: exploded");
   });
 
+  it("titles shell status lines with the model-authored intent when present (stigmer#276)", () => {
+    const { status } = render([
+      {
+        kind: "toolRunning",
+        toolCallId: "t1",
+        subAgentId: "",
+        toolCall: toolInfo({
+          name: "execute",
+          status: "running",
+          args: { command: "npx vitest run src/parser", description: "Run unit tests for the parser" },
+        }),
+      },
+      {
+        kind: "toolCompleted",
+        toolCallId: "t1",
+        subAgentId: "",
+        toolCall: toolInfo({
+          name: "execute",
+          args: { command: "npx vitest run src/parser", description: "Run unit tests for the parser" },
+        }),
+      },
+    ]);
+    expect(status).toContain("⠋ Run unit tests for the parser");
+    expect(status).toContain("✓ Run unit tests for the parser");
+    expect(status).not.toContain("execute");
+  });
+
+  it("keeps the raw tool name when there is no intent, and never titles non-shell tools from description", () => {
+    const { status } = render([
+      {
+        kind: "toolCompleted",
+        toolCallId: "t1",
+        subAgentId: "",
+        toolCall: toolInfo({ name: "execute", args: { command: "ls" } }),
+      },
+      {
+        kind: "toolCompleted",
+        toolCallId: "t2",
+        subAgentId: "",
+        toolCall: toolInfo({
+          name: "task",
+          args: { description: "general-purpose research", prompt: "Find the docs" },
+        }),
+      },
+    ]);
+    // A task tool's description is the sub-agent subject, never a row title.
+    expect(status).toContain("✓ execute");
+    expect(status).toContain("✓ task");
+    expect(status).not.toContain("general-purpose research");
+  });
+
   it("renders an interrupted tool with the neutral glyph, not a checkmark (issue #207)", () => {
     const { status } = render([
       { kind: "toolInterrupted", toolCallId: "t1", subAgentId: "", toolCall: toolInfo({ name: "shell", status: "interrupted" }) },

package/src/resources/stream/render-plaintext.ts

@@ -1,13 +1,14 @@
 // Plaintext headless renderer for non-TTY output (piped stdout).
 //
-// Mirrors Go's streamAgentPlainText (run_stream_plaintext.go): clean AI text to
+// Inherited from the retired Go CLI's streamAgentPlainText: clean AI text to
 // the data sink (stdout), terse tool/status lines to the status sink (stderr).
 // No ANSI, no frames. Approvals are auto-skipped — there is no keyboard here;
 // use --json for a machine-readable non-TTY stream. Phase/done/stream-error are
 // not rendered: the driver returns the outcome and the command surfaces it.
 
 import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { ApprovalNeededEvent, StreamEvent } from "./events.js";
+import { resolveToolKindByName, shellIntentFromArgs } from "@stigmer/sdk";
+import type { ApprovalNeededEvent, StreamEvent, ToolCallInfo } from "./events.js";
 import type { HeadlessRenderer } from "./headless.js";
 import type { LineWriter } from "./render-ndjson.js";
 
@@ -40,17 +41,17 @@ export class PlaintextRenderer implements HeadlessRenderer {
         status.write(`\n> ${event.content}\n\n`);
         return;
       case "toolRunning":
-        status.write(`  ⠋ ${event.toolCall.name}\n`);
+        status.write(`  ⠋ ${toolLine(event.toolCall)}\n`);
         return;
       case "toolCompleted":
         status.write(
           event.toolCall.error !== ""
-            ? `  ✗ ${event.toolCall.name}: ${truncate(event.toolCall.error, MAX_ERROR_LEN)}\n`
-            : `  ✓ ${event.toolCall.name}\n`,
+            ? `  ✗ ${toolLine(event.toolCall)}: ${truncate(event.toolCall.error, MAX_ERROR_LEN)}\n`
+            : `  ✓ ${toolLine(event.toolCall)}\n`,
         );
         return;
       case "toolInterrupted":
-        status.write(`  ⊘ ${event.toolCall.name} (interrupted)\n`);
+        status.write(`  ⊘ ${toolLine(event.toolCall)} (interrupted)\n`);
         return;
       case "approvalNeeded":
         status.write(`  ⚠ Approval needed: ${event.toolName} (auto-skipped in non-TTY mode)\n`);
@@ -82,6 +83,23 @@ export class PlaintextRenderer implements HeadlessRenderer {
   }
 }
 
+/**
+ * The status-line label for a tool call: the model-authored intent phrase
+ * when the shell call carries one (stigmer#276) — the same convention that
+ * titles rows in the web console and the Ink TTY path — otherwise the raw
+ * tool name. Kind is resolved by name only: the snapshot projection carries
+ * neither `tool_kind` nor `mcp_server_slug`, and MCP tools never carry an
+ * intent (the fixture pins them to null), so name-lookup is sufficient here.
+ * NDJSON is deliberately untouched — it is the machine contract.
+ */
+function toolLine(toolCall: ToolCallInfo): string {
+  const intent = shellIntentFromArgs(
+    resolveToolKindByName(toolCall.name),
+    toolCall.args,
+  );
+  return intent ?? toolCall.name;
+}
+
 // Trim and ellipsize. Mirrors Go's truncate.
 function truncate(value: string, maxLen: number): string {
   const trimmed = value.trim();

package/src/resources/session.test.ts

@@ -1,48 +0,0 @@
-import { create } from "@bufbuild/protobuf";
-import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
-import { SessionListSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/io_pb";
-import { describe, expect, it } from "vitest";
-import { isSessionAlias, renderSessionList } from "./session.js";
-
-describe("isSessionAlias", () => {
-  it.each([
-    ["session", true],
-    ["sessions", true],
-    ["  Session ", true],
-    ["execution", false],
-    ["agent", false],
-  ])("%j -> %s", (type, expected) => {
-    expect(isSessionAlias(type)).toBe(expected);
-  });
-});
-
-describe("renderSessionList", () => {
-  const list = create(SessionListSchema, {
-    totalPages: 1,
-    entries: [
-      create(SessionSchema, {
-        metadata: { id: "ses_1" },
-        spec: { agentInstanceId: "agi_1", subject: "Fix the build" },
-      }),
-    ],
-  });
-  const result = { schema: SessionListSchema, message: list };
-
-  it("renders the full list envelope as protojson for json", () => {
-    const json = JSON.parse(renderSessionList(result, "json"));
-    expect(json.entries[0].metadata.id).toBe("ses_1");
-  });
-
-  it("renders a table with the session columns", () => {
-    const table = renderSessionList(result, "table");
-    expect(table).toContain("SESSION ID");
-    expect(table).toContain("ses_1");
-    expect(table).toContain("agi_1");
-    expect(table).toContain("Fix the build");
-  });
-
-  it("renders an empty notice for no sessions", () => {
-    const empty = { schema: SessionListSchema, message: create(SessionListSchema, {}) };
-    expect(renderSessionList(empty, "table").toLowerCase()).toContain("no sessions");
-  });
-});