@dexh/shannon 0.0.1 → 0.0.2

package/README.md

@@ -1,72 +1,43 @@
 # Shannon
 
-Shannon is a CLI and SDK wrapper around the interactive Claude Code CLI. It starts a real `claude` session inside tmux, sends a prompt, tails Claude's on-disk transcript, emits stream JSON, and cleans up the tmux session on exit.
-
-The first supported path is:
-
-```sh
-shannon -p "hi i'm tom" --output-format=stream-json --verbose
-```
-
-Shannon does not use `claude -p` internally.
+Shannon is a CLI and SDK wrapper around the interactive Claude Code CLI. It runs a real `claude` session inside tmux, sends a prompt, and emits stream JSON.
 
 ## Requirements
 
-- Bun
+- [Bun](https://bun.sh)
 - `claude` on `PATH`
 - `tmux` on `PATH`
-- A working Claude Code login/configuration
+- A working Claude Code login
 
-## Install
-
-```sh
-bun install
-bun link
-```
+## CLI
 
-After linking, `shannon` should resolve from your Bun bin directory:
+Run without installing:
 
 ```sh
-which shannon
+npx @dexh/shannon -p "Reply with exactly: hello" --output-format=stream-json --verbose
 ```
 
-## CLI
+Or install globally:
 
 ```sh
+npm install -g @dexh/shannon
 shannon -p "Reply with exactly: hello" --output-format=stream-json --verbose
 ```
 
-Incremental stdin JSONL input is supported for one or more user messages:
+Output formats: `stream-json` (JSONL), `json` (single array), `text` (final result text).
+
+## SDK
 
 ```sh
-printf '%s\n' '{"type":"user","message":{"role":"user","content":[{"type":"text","text":"Reply with exactly: hello"}]},"parent_tool_use_id":null,"session_id":""}' \
-  | shannon --input-format=stream-json --output-format=stream-json --verbose --replay-user-messages
+npm install @dexh/shannon
 ```
 
-Current stream shape:
-
-- `system` / `hook_response` when interactive transcript hook attachments are present
-- `system` / `init`
-- `assistant`
-- synthesized `result` / `success`
-- final `shannon_session` / `metadata`
-
-The final metadata row includes the Claude session id, transcript path, project session folder, tmux session name, cwd, and cleanup status.
-
-`--output-format=json` emits one JSON array containing Shannon's supported
-message rows. `--output-format=text` emits the final result text.
-
-## SDK
-
 ```ts
-import { query } from "@humanlayer/shannon";
+import { query } from "@dexh/shannon";
 
 for await (const message of query({
   prompt: "Reply with exactly: hello",
-  options: {
-    outputFormat: "stream-json",
-    verbose: true,
-  },
+  options: { outputFormat: "stream-json", verbose: true },
 })) {
   console.log(JSON.stringify(message));
 }
@@ -75,7 +46,7 @@ for await (const message of query({
 Async input is also accepted for finite user-message streams:
 
 ```ts
-import { query, type ShannonUserMessage } from "@humanlayer/shannon";
+import { query, type ShannonUserMessage } from "@dexh/shannon";
 
 async function* messages(): AsyncIterable<ShannonUserMessage> {
   yield {
@@ -94,36 +65,32 @@ for await (const message of query({ prompt: messages() })) {
 }
 ```
 
-Queries accept an `AbortController` in options; aborting it terminates the
-underlying Shannon subprocess.
+Pass an `AbortController` in options to terminate the underlying Shannon subprocess.
 
-The SDK also exports zod schemas for the current Shannon message, options, and
-query parameter surface:
+## Agent SDK facade
 
-```ts
-import { shannonMessageSchema, shannonQueryOptionsSchema } from "@humanlayer/shannon";
+`@dexh/shannon-agent-sdk` is a Claude Agent SDK-compatible facade that re-exports Shannon's SDK surface. Full parity is a work in progress (see `GOAL_PROGRESS.md`).
+
+```sh
+npm install @dexh/shannon-agent-sdk
 ```
 
-The SDK facade shells out to the `shannon` executable and parses JSONL stdout into an async iterable.
+```ts
+import { query } from "@dexh/shannon-agent-sdk";
 
-The repo also includes `packages/shannon-agent-sdk`, a thin
-`@humanlayer/shannon-agent-sdk` facade over the implemented Shannon SDK surface.
-It is not full Claude Agent SDK parity yet.
+for await (const message of query({
+  prompt: "Reply with exactly: hello",
+  options: { outputFormat: "stream-json", verbose: true },
+})) {
+  console.log(JSON.stringify(message));
+}
+```
 
 ## Development
 
 ```sh
+bun install
 bun test
 bun run typecheck
-```
-
-CI runs the same non-live checks plus package dry-runs for both packages.
-The publish workflow publishes `@humanlayer/shannon` and
-`@humanlayer/shannon-agent-sdk` from a GitHub release or manual dispatch when
-`NPM_TOKEN` is configured.
-
-Run the CLI directly:
-
-```sh
 bun ./index.ts -p "hello" --output-format=stream-json --verbose
 ```

package/index.ts

@@ -629,10 +629,10 @@ export async function runShannon(options: CliOptions) {
   const prompts = options.prompt
     ? asyncIterableFromArray([options.prompt])
     : readPromptsFromStdin(options.inputFormat);
+  const promptIterator = prompts[Symbol.asyncIterator]();
   let meta: SessionMetadata | undefined;
   let transcriptRowCount = 0;
   let cleanup: JsonRecord = { tmux_killed: false };
-  let promptReady = false;
   let promptCount = 0;
   let cleanupStarted = false;
   let metadataEmitted = false;
@@ -657,6 +657,12 @@ export async function runShannon(options: CliOptions) {
   });
 
   try {
+    let prompt = await nextPrompt(promptIterator);
+    if (!prompt) {
+      throw new Error("Expected at least one user message on stdin for --input-format=stream-json");
+    }
+
+    const firstPromptSentAt = Date.now();
     await runCommand([
       "tmux",
       "new-session",
@@ -667,27 +673,23 @@ export async function runShannon(options: CliOptions) {
       options.cwd,
       "claude",
       ...options.claudeArgs,
+      prompt,
     ]);
-    await waitForPrompt(tmuxSession);
-    promptReady = true;
 
-    for await (const prompt of prompts) {
-      if (!prompt) continue;
+    let launchedWithPrompt = true;
+    while (prompt) {
       promptCount += 1;
 
-      if (!promptReady) {
+      const promptSentAt = launchedWithPrompt ? firstPromptSentAt : Date.now();
+      if (!launchedWithPrompt) {
         await waitForPrompt(tmuxSession);
-        promptReady = true;
+        await sendPrompt(tmuxSession, prompt);
       }
 
       if (options.replayUserMessages && options.outputFormat === "stream-json") {
         emitJson(toUserReplay(prompt));
       }
 
-      const promptSentAt = Date.now();
-      await sendPrompt(tmuxSession, prompt);
-      promptReady = false;
-
       if (!meta) {
         const discovery = await waitForSessionWithPrompt(
           projectFolder,
@@ -741,10 +743,9 @@ export async function runShannon(options: CliOptions) {
       } else {
         emitOutput(options.outputFormat, turnMessages);
       }
-    }
 
-    if (promptCount === 0) {
-      throw new Error("Expected at least one user message on stdin for --input-format=stream-json");
+      launchedWithPrompt = false;
+      prompt = await nextPrompt(promptIterator);
     }
 
     if (options.outputFormat === "json") {
@@ -925,10 +926,17 @@ async function waitForPrompt(tmuxSession: string) {
 async function sendPrompt(tmuxSession: string, prompt: string) {
   await runCommand(["tmux", "set-buffer", "-b", `shannon-${tmuxSession}`, prompt]);
   await runCommand(["tmux", "paste-buffer", "-b", `shannon-${tmuxSession}`, "-t", tmuxSession]);
-  await runCommand(["tmux", "send-keys", "-t", tmuxSession, "Escape"]);
   await runCommand(["tmux", "send-keys", "-t", tmuxSession, "C-m"]);
 }
 
+async function nextPrompt(iterator: AsyncIterator<string>): Promise<string | undefined> {
+  while (true) {
+    const next = await iterator.next();
+    if (next.done) return undefined;
+    if (next.value) return next.value;
+  }
+}
+
 async function waitForAssistantReply(
   transcriptPath: string,
   prompt: string,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexh/shannon",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "CLI and SDK wrapper that drives interactive Claude Code through tmux and emits stream-json.",
   "license": "MIT",
   "homepage": "https://github.com/humanlayer/shannon#readme",