@cam5/baby-bird 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -135,7 +135,7 @@ declare const LlmTourOutputSchema: z.ZodObject<{
         files: z.ZodOptional<z.ZodArray<z.ZodString>>;
         excerpts: z.ZodOptional<z.ZodArray<z.ZodObject<{
             hunk: z.ZodString;
-            lines: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            lines: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
             note: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
@@ -214,10 +214,24 @@ declare const TourSchema: z.ZodObject<{
 declare function formatIssues(error: z.ZodError): string;
 
 type PromptVia = 'stdin' | 'arg';
+type LlmKind = 'plain' | 'claude';
 interface LlmPreset {
     /** argv; when promptVia is "arg", any "{prompt}" token is replaced with the prompt. */
     command: string[];
+    /**
+     * argv for `bb ask`: an interactive chat about a tour. Tokens: "{context-file}" is the path of a
+     * file holding the tour context (a system prompt), "{context}" is that text inline, and
+     * "{message}" is the user's opening message (argv entries that are only "{message}" are dropped
+     * when there is none).
+     */
+    chatCommand?: string[];
     promptVia?: PromptVia;
+    /**
+     * "claude": the Claude Code CLI; streaming flags and --json-schema are added
+     * automatically so thinking can be shown live and the answer is schema-checked.
+     * "plain" (default): stdout is the answer.
+     */
+    kind?: LlmKind;
     description?: string;
 }
 declare const BUILTIN_PRESETS: Readonly<Record<string, LlmPreset>>;
@@ -226,18 +240,29 @@ declare const ConfigSchema: z.ZodObject<{
         preset: z.ZodString;
         presets: z.ZodRecord<z.ZodString, z.ZodObject<{
             command: z.ZodArray<z.ZodString>;
+            chatCommand: z.ZodOptional<z.ZodArray<z.ZodString>>;
             promptVia: z.ZodOptional<z.ZodEnum<{
                 stdin: "stdin";
                 arg: "arg";
             }>>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                plain: "plain";
+                claude: "claude";
+            }>>;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         args: z.ZodArray<z.ZodString>;
         command: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        chatCommand: z.ZodNullable<z.ZodArray<z.ZodString>>;
         promptVia: z.ZodNullable<z.ZodEnum<{
             stdin: "stdin";
             arg: "arg";
         }>>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            plain: "plain";
+            claude: "claude";
+        }>>;
+        jsonSchema: z.ZodBoolean;
         timeoutMs: z.ZodNumber;
         maxPromptBytes: z.ZodNumber;
         env: z.ZodRecord<z.ZodString, z.ZodString>;
@@ -265,6 +290,11 @@ declare const ConfigSchema: z.ZodObject<{
         }>;
         maxExcerptLines: z.ZodNumber;
         width: z.ZodNullable<z.ZodNumber>;
+        highlight: z.ZodEnum<{
+            never: "never";
+            auto: "auto";
+            always: "always";
+        }>;
     }, z.core.$strip>;
     cache: z.ZodObject<{
         enabled: z.ZodBoolean;
@@ -277,18 +307,29 @@ declare const PartialConfigSchema: z.ZodObject<{
         preset: z.ZodOptional<z.ZodString>;
         presets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             command: z.ZodArray<z.ZodString>;
+            chatCommand: z.ZodOptional<z.ZodArray<z.ZodString>>;
             promptVia: z.ZodOptional<z.ZodEnum<{
                 stdin: "stdin";
                 arg: "arg";
             }>>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                plain: "plain";
+                claude: "claude";
+            }>>;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
         args: z.ZodOptional<z.ZodArray<z.ZodString>>;
         command: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        chatCommand: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
         promptVia: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             stdin: "stdin";
             arg: "arg";
         }>>>;
+        kind: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            plain: "plain";
+            claude: "claude";
+        }>>>;
+        jsonSchema: z.ZodOptional<z.ZodBoolean>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
         maxPromptBytes: z.ZodOptional<z.ZodNumber>;
         env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -316,6 +357,11 @@ declare const PartialConfigSchema: z.ZodObject<{
         }>>;
         maxExcerptLines: z.ZodOptional<z.ZodNumber>;
         width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        highlight: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            auto: "auto";
+            always: "always";
+        }>>;
     }, z.core.$strip>>;
     cache: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -356,6 +402,9 @@ declare function loadConfig(opts?: LoadConfigOptions): Promise<LoadedConfig>;
 interface ResolvedLlm {
     command: string[];
     promptVia: PromptVia;
+    kind: LlmKind;
+    /** Whether to hand the answer schema to the runner (Claude kind only). */
+    jsonSchema: boolean;
     /** Preset name, or null when a custom command is in use. */
     preset: string | null;
     timeoutMs: number;
@@ -364,6 +413,15 @@ interface ResolvedLlm {
 }
 declare function allPresets(config: Config): Record<string, LlmPreset>;
 declare function resolveLlm(config: Config): ResolvedLlm;
+interface ResolvedChat {
+    /** argv template; see LlmPreset.chatCommand for the tokens. */
+    command: string[];
+    /** Preset name the command came from, or null for llm.chatCommand / a custom command. */
+    preset: string | null;
+    env: Record<string, string>;
+}
+/** The interactive command `bb ask` runs. Errors when neither the preset nor llm.chatCommand provides one. */
+declare function resolveChat(config: Config): ResolvedChat;
 /** Minimal POSIX-ish shell splitting: whitespace separated, single/double quotes, backslash escapes. */
 declare function shellSplit(input: string): string[];
 
@@ -452,14 +510,19 @@ declare function materializeTour(input: MaterializeInput): Tour;
  */
 declare function sliceHunk(hunk: Hunk, range: [number, number] | undefined, maxLines: number): HunkLine[];
 
-interface PromptInput {
+/** The change as gathered from git and the code host. */
+interface ChangeInput {
     source: TourSource;
     branch: string | null;
     diff: ParsedDiff;
     commits: CommitInfo[];
     pullRequest?: PullRequestInfo;
+}
+interface PromptInput extends ChangeInput {
     /** Soft budget for the whole prompt, in bytes. */
     maxBytes: number;
+    /** The runner enforces the JSON schema itself (e.g. claude --json-schema); adjusts the output instruction. */
+    structured?: boolean;
 }
 interface TruncationReport {
     /** Files whose diff was cut down to the start of their first hunk. */
@@ -472,10 +535,20 @@ interface BuiltPrompt {
     truncation: TruncationReport;
 }
 declare function buildPrompt(input: PromptInput): BuiltPrompt;
+/**
+ * The change itself: source, PR text, commit subjects, the file table, and the diff with every
+ * hunk labeled by id. Diffs are shortened biggest-file-first to fit `maxBytes`.
+ */
+declare function renderChange(input: ChangeInput, maxBytes: number): {
+    text: string;
+    truncation: TruncationReport;
+};
 declare function describeSource(source: TourSource, branch: string | null): string;
 
 /** Bump whenever the prompt text or its assembly changes materially; it is part of the cache key. */
-declare const PROMPT_VERSION = 2;
+declare const PROMPT_VERSION = 3;
+/** The fixed part of the prompt; `structured` picks the wording for CLIs that enforce a schema themselves. */
+declare function promptHeader(structured: boolean): string;
 
 interface CodeHost {
     readonly name: string;
@@ -527,17 +600,67 @@ interface ResolvedRange {
 declare function resolveRange(req: RangeRequest, opts: ResolveOptions): Promise<ResolvedRange>;
 declare function detectDefaultBranch(configured: string | null, cwd: string): Promise<string | null>;
 
+/** Events a provider may emit while a completion is in flight. */
+type LlmEvent = {
+    type: 'started';
+}
+/** A chunk of the model's (summarized) reasoning, when the runner exposes it. */
+ | {
+    type: 'thinking';
+    text: string;
+}
+/** The model is reasoning but the runner does not expose the text (Claude Code's print mode sends empty deltas). */
+ | {
+    type: 'thinking-pulse';
+}
+/** A chunk of the answer as it is produced. */
+ | {
+    type: 'text';
+    text: string;
+}
+/** The model started a (new) answer; any previously streamed answer text is superseded. */
+ | {
+    type: 'answer-start';
+}
+/** Something worth telling the user, e.g. the CLI rejected an answer and the model is retrying. */
+ | {
+    type: 'notice';
+    text: string;
+}
+/** Opaque progress for commands we cannot parse: total stdout bytes so far. */
+ | {
+    type: 'output';
+    bytes: number;
+} | {
+    type: 'usage';
+    outputTokens?: number;
+    thinkingTokens?: number;
+    costUsd?: number;
+    model?: string;
+};
+interface CompleteOptions {
+    onEvent?: (event: LlmEvent) => void;
+}
 interface LlmProvider {
     /** Human-readable description of how the model is invoked, for headers and debug output. */
     describe(): string;
     /** Send a prompt and return the raw text the model produced. */
-    complete(prompt: string): Promise<string>;
+    complete(prompt: string, opts?: CompleteOptions): Promise<string>;
 }
 
+type CommandKind = 'plain' | 'claude';
 interface CommandProviderOptions {
     command: string[];
     promptVia: 'stdin' | 'arg';
     timeoutMs: number;
+    /**
+     * "plain": stdout is the answer. "claude": the command is the Claude Code CLI;
+     * streaming flags (and --json-schema when a schema is given) are appended and
+     * the stream-json output is parsed for live thinking/text events.
+     */
+    kind?: CommandKind;
+    /** JSON Schema the answer must satisfy (Claude kind only). */
+    jsonSchema?: object;
     env?: Record<string, string>;
     cwd?: string;
     debug?: (msg: string) => void;
@@ -546,8 +669,55 @@ interface CommandProviderOptions {
 declare class CommandProvider implements LlmProvider {
     private readonly opts;
     constructor(opts: CommandProviderOptions);
+    get kind(): CommandKind;
     describe(): string;
-    complete(prompt: string): Promise<string>;
+    /** The full argv that will run, including any flags added for the command kind. */
+    argv(prompt?: string): string[];
+    complete(prompt: string, opts?: CompleteOptions): Promise<string>;
+}
+
+/**
+ * Incremental parser for `claude -p --output-format stream-json --verbose
+ * --include-partial-messages`. Emits thinking/text events as deltas arrive and
+ * collects the final result (structured output when --json-schema is in use).
+ */
+interface ClaudeStreamUsage {
+    outputTokens?: number;
+    thinkingTokens?: number;
+    costUsd?: number;
+    model?: string;
+}
+interface ClaudeStreamOutcome {
+    /** Final answer text; structured output is serialized as JSON. */
+    result: string | null;
+    isError: boolean;
+    errorMessage?: string;
+    usage: ClaudeStreamUsage;
+    /** Lines on stdout that were not JSON (for debugging). */
+    unparsedLines: number;
+}
+declare class ClaudeStreamParser {
+    private readonly onEvent;
+    private buffer;
+    private text;
+    private partialJson;
+    private messageStructured;
+    private resultStructured;
+    private resultText;
+    private isError;
+    private errorMessage;
+    private usage;
+    private unparsed;
+    constructor(onEvent?: (event: LlmEvent) => void);
+    push(chunk: string): void;
+    finish(): ClaudeStreamOutcome;
+    private handleLine;
+    private handleStreamEvent;
+    private handleAssistant;
+    /** Tool results the CLI feeds back, e.g. a structured-output validation failure. */
+    private handleUser;
+    private handleResult;
+    private recordUsage;
 }
 
 declare function createProvider(llm: ResolvedLlm, opts?: {
@@ -555,6 +725,15 @@ declare function createProvider(llm: ResolvedLlm, opts?: {
     debug?: (msg: string) => void;
 }): LlmProvider;
 
+/** Where the pipeline reports what it is doing. The CLI renders this live; other consumers may ignore it. */
+interface ProgressSink {
+    /** A new stage began (e.g. "Collecting the diff"). */
+    phase(label: string): void;
+    /** Something happened inside the model call. */
+    llm(event: LlmEvent): void;
+}
+declare const noProgress: ProgressSink;
+
 interface TourOptions {
     /** Git root (or any directory inside the repository). */
     cwd: string;
@@ -567,6 +746,8 @@ interface TourOptions {
     noCache?: boolean;
     debug?: (msg: string) => void;
     warn?: (msg: string) => void;
+    /** Receives stage changes and model events; the CLI renders these live. */
+    progress?: ProgressSink;
     /** Injectable for tests. */
     provider?: LlmProvider;
     codehost?: CodeHost;
@@ -589,6 +770,23 @@ interface TourResult {
 declare function prepareTour(opts: TourOptions): Promise<PreparedTour>;
 declare function generateTour(opts: TourOptions, prepared?: PreparedTour): Promise<TourResult>;
 
+interface ChatContextInput {
+    tour: Tour;
+    /** The change the tour was built from, as gathered by prepareTour. */
+    change: ChangeInput;
+    /** Soft budget for the whole context, in bytes; the tour is always kept and the diff is shortened to fit. */
+    maxBytes: number;
+    /** Where the tour JSON lives on disk, when cached, so a tool-using assistant can open it. */
+    tourPath?: string | null;
+}
+interface ChatContext {
+    /** Markdown meant for a system prompt: framing, the tour, then the change and its diff. */
+    text: string;
+    truncation: TruncationReport;
+}
+/** The text `bb ask` hands to the chat command as context. */
+declare function buildChatContext(input: ChatContextInput): ChatContext;
+
 interface CollectOptions {
     cwd: string;
     exclude: string[];
@@ -615,6 +813,117 @@ declare function diffStats(diff: ParsedDiff): {
     deletions: number;
 };
 
+interface ChatArgvInput {
+    command: string[];
+    contextFile: string;
+    context: string;
+    message?: string;
+}
+/** Fill the tokens in a chat command. Entries that are exactly "{message}" are dropped when there is no message. */
+declare function chatArgv(input: ChatArgvInput): string[];
+/** Which tokens a chat command uses, so the caller can warn about a message or context that would go nowhere. */
+declare function chatSlots(command: string[]): {
+    context: boolean;
+    message: boolean;
+};
+interface LaunchChatOptions {
+    /** argv template; see chatArgv for the tokens. */
+    command: string[];
+    /** The system-prompt-like context, written to a temp file for "{context-file}". */
+    context: string;
+    /** Opening message, if any. */
+    message?: string;
+    cwd: string;
+    env?: Record<string, string>;
+    debug?: (msg: string) => void;
+    /** Defaults to the terminal ("inherit"); tests use "ignore". */
+    stdio?: 'inherit' | 'ignore';
+}
+interface ChatOutcome {
+    /** The command's exit code, or 128 + signal number when a signal ended it. */
+    exitCode: number;
+    signal: NodeJS.Signals | null;
+}
+/**
+ * Run an interactive chat command in the foreground, attached to this terminal, and resolve when it
+ * exits. Ctrl+C reaches the child through the terminal, so bb ignores SIGINT itself while the chat
+ * runs; SIGTERM and SIGHUP are forwarded.
+ */
+declare function launchChat(opts: LaunchChatOptions): Promise<ChatOutcome>;
+
+/**
+ * JSON Schema for the model's answer, handed to `claude --json-schema` so the
+ * CLI enforces the shape itself. Kept deliberately simple (no tuples, no
+ * optionals) for structured-output compatibility; zod does the final check.
+ */
+declare const TOUR_JSON_SCHEMA: {
+    readonly type: "object";
+    readonly description: "The tour itself. Its fields (title, summary, sections) are the top-level properties of this object; do not wrap them in another key.";
+    readonly additionalProperties: false;
+    readonly required: readonly ["title", "summary", "sections"];
+    readonly properties: {
+        readonly title: {
+            readonly type: "string";
+            readonly description: "Short imperative title naming the change, like a good commit subject.";
+        };
+        readonly summary: {
+            readonly type: "string";
+            readonly description: "2 to 4 sentences describing the whole change and its motivation.";
+        };
+        readonly sections: {
+            readonly type: "array";
+            readonly description: "Ordered sections of the tour, 2 to 8 of them.";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["title", "description", "files", "excerpts"];
+                readonly properties: {
+                    readonly title: {
+                        readonly type: "string";
+                    };
+                    readonly description: {
+                        readonly type: "string";
+                        readonly description: "Why, then what, then what to watch. 2 to 5 sentences.";
+                    };
+                    readonly files: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Paths this section is about, exactly as listed.";
+                    };
+                    readonly excerpts: {
+                        readonly type: "array";
+                        readonly description: "1 to 3 hunks that best show the idea.";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: false;
+                            readonly required: readonly ["hunk", "lines", "note"];
+                            readonly properties: {
+                                readonly hunk: {
+                                    readonly type: "string";
+                                    readonly description: "A hunk id exactly as given in the diff, e.g. \"F2.H1\".";
+                                };
+                                readonly lines: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "integer";
+                                    };
+                                    readonly description: "Empty for the whole hunk, or [start, end] new-file line numbers to narrow it.";
+                                };
+                                readonly note: {
+                                    readonly type: "string";
+                                    readonly description: "Under 15 words: what to look at. May be empty.";
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+
 interface RenderOptions {
     /** Emit ANSI colors. */
     color: boolean;
@@ -624,6 +933,8 @@ interface RenderOptions {
     section?: number;
     /** Whether the tour came from the cache, for the header note. */
     fromCache?: boolean;
+    /** Language-aware token colors in excerpts. Needs color. */
+    highlight?: boolean;
 }
 interface Renderer {
     render(tour: Tour, opts: RenderOptions): string;
@@ -645,4 +956,4 @@ interface PagerOptions {
 /** Write output to stdout, through $PAGER (default `less -RFX`) when it would not fit the screen. */
 declare function writeMaybePaged(output: string, opts: PagerOptions): Promise<void>;
 
-export { BUILTIN_PRESETS, BadLlmOutputError, BbError, type BuiltPrompt, type CacheEntry, CliRenderer, type CodeHost, CommandProvider, type CommitInfo, type Config, ConfigError, type ConfigLayer, ConfigSchema, DEFAULT_CONFIG, type DiffFile, type Excerpt, type FileStatus, GhCodeHost, GitError, type Hunk, type HunkLine, type LineType, LlmFailedError, type LlmPreset, type LlmProvider, type LlmTourOutput, LlmTourOutputSchema, type LoadedConfig, NoChangesError, NoCodeHost, NotARepoError, OTHER_CHANGES_TITLE, PROMPT_VERSION, type ParsedDiff, type PartialConfig, PartialConfigSchema, type PreparedTour, type PromptInput, type PullRequestInfo, type RangeRequest, type RangeResolvedBy, type RenderOptions, type Renderer, type ResolveOptions, type ResolvedLlm, type ResolvedRange, type Section, type Tour, TourCache, type TourContext, type TourGenerator, type TourOptions, type TourResult, TourSchema, type TourSource, type TourStats, type TruncationReport, UsageError, type WorkingResolvedBy, allPresets, buildPrompt, collectCommits, collectDiff, createCodeHost, createProvider, currentBranch, deepMerge, defaultCacheDir, describeSource, detectDefaultBranch, diffStats, extractJson, formatIssues, generateTour, gitRoot, loadConfig, materializeTour, parseDiff, prepareTour, projectConfigPath, relativeTime, resolveLlm, resolveRange, revParse, shellSplit, sliceHunk, userConfigPath, wrap, writeMaybePaged };
+export { BUILTIN_PRESETS, BadLlmOutputError, BbError, type BuiltPrompt, type CacheEntry, type ChangeInput, type ChatContext, type ChatContextInput, type ChatOutcome, ClaudeStreamParser, CliRenderer, type CodeHost, type CommandKind, CommandProvider, type CommitInfo, type CompleteOptions, type Config, ConfigError, type ConfigLayer, ConfigSchema, DEFAULT_CONFIG, type DiffFile, type Excerpt, type FileStatus, GhCodeHost, GitError, type Hunk, type HunkLine, type LaunchChatOptions, type LineType, type LlmEvent, LlmFailedError, type LlmKind, type LlmPreset, type LlmProvider, type LlmTourOutput, LlmTourOutputSchema, type LoadedConfig, NoChangesError, NoCodeHost, NotARepoError, OTHER_CHANGES_TITLE, PROMPT_VERSION, type ParsedDiff, type PartialConfig, PartialConfigSchema, type PreparedTour, type ProgressSink, type PromptInput, type PullRequestInfo, type RangeRequest, type RangeResolvedBy, type RenderOptions, type Renderer, type ResolveOptions, type ResolvedChat, type ResolvedLlm, type ResolvedRange, type Section, TOUR_JSON_SCHEMA, type Tour, TourCache, type TourContext, type TourGenerator, type TourOptions, type TourResult, TourSchema, type TourSource, type TourStats, type TruncationReport, UsageError, type WorkingResolvedBy, allPresets, buildChatContext, buildPrompt, chatArgv, chatSlots, collectCommits, collectDiff, createCodeHost, createProvider, currentBranch, deepMerge, defaultCacheDir, describeSource, detectDefaultBranch, diffStats, extractJson, formatIssues, generateTour, gitRoot, launchChat, loadConfig, materializeTour, noProgress, parseDiff, prepareTour, projectConfigPath, promptHeader, relativeTime, renderChange, resolveChat, resolveLlm, resolveRange, revParse, shellSplit, sliceHunk, userConfigPath, wrap, writeMaybePaged };

package/dist/index.js

@@ -2,6 +2,7 @@ import {
   BUILTIN_PRESETS,
   BadLlmOutputError,
   BbError,
+  ClaudeStreamParser,
   CliRenderer,
   CommandProvider,
   ConfigError,
@@ -17,11 +18,15 @@ import {
   OTHER_CHANGES_TITLE,
   PROMPT_VERSION,
   PartialConfigSchema,
+  TOUR_JSON_SCHEMA,
   TourCache,
   TourSchema,
   UsageError,
   allPresets,
+  buildChatContext,
   buildPrompt,
+  chatArgv,
+  chatSlots,
   collectCommits,
   collectDiff,
   createCodeHost,
@@ -36,12 +41,17 @@ import {
   formatIssues,
   generateTour,
   gitRoot,
+  launchChat,
   loadConfig,
   materializeTour,
+  noProgress,
   parseDiff,
   prepareTour,
   projectConfigPath,
+  promptHeader,
   relativeTime,
+  renderChange,
+  resolveChat,
   resolveLlm,
   resolveRange,
   revParse,
@@ -50,11 +60,12 @@ import {
   userConfigPath,
   wrap,
   writeMaybePaged
-} from "./chunk-RWSCST2I.js";
+} from "./chunk-YI2UL4IC.js";
 export {
   BUILTIN_PRESETS,
   BadLlmOutputError,
   BbError,
+  ClaudeStreamParser,
   CliRenderer,
   CommandProvider,
   ConfigError,
@@ -70,11 +81,15 @@ export {
   OTHER_CHANGES_TITLE,
   PROMPT_VERSION,
   PartialConfigSchema,
+  TOUR_JSON_SCHEMA,
   TourCache,
   TourSchema,
   UsageError,
   allPresets,
+  buildChatContext,
   buildPrompt,
+  chatArgv,
+  chatSlots,
   collectCommits,
   collectDiff,
   createCodeHost,
@@ -89,12 +104,17 @@ export {
   formatIssues,
   generateTour,
   gitRoot,
+  launchChat,
   loadConfig,
   materializeTour,
+  noProgress,
   parseDiff,
   prepareTour,
   projectConfigPath,
+  promptHeader,
   relativeTime,
+  renderChange,
+  resolveChat,
   resolveLlm,
   resolveRange,
   revParse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cam5/baby-bird",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Guided code tours for git changes, on the command line.",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,7 @@
   },
   "dependencies": {
     "commander": "^15.0.0",
+    "lowlight": "^3.3.0",
     "picocolors": "^1.1.1",
     "zod": "^4.6.2"
   },