wiggum-cli 0.16.0 → 0.17.0

package/dist/agent/tools/reporting.js

@@ -0,0 +1,119 @@
+import { tool, zodSchema } from 'ai';
+import { z } from 'zod';
+import { execFile } from 'node:child_process';
+function ghExec(args) {
+    return new Promise((resolve, reject) => {
+        execFile('gh', args, { timeout: 15000 }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(String(stdout));
+        });
+    });
+}
+export function createReportingTools(owner, repo) {
+    const commentOnIssue = tool({
+        description: 'Post a status comment on a GitHub issue.',
+        inputSchema: zodSchema(z.object({
+            issueNumber: z.number().int().describe('Issue number to comment on'),
+            body: z.string().describe('Comment body in markdown'),
+        })),
+        execute: async ({ issueNumber, body }) => {
+            try {
+                await ghExec([
+                    'issue', 'comment', String(issueNumber),
+                    '--repo', `${owner}/${repo}`,
+                    '--body', body,
+                ]);
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    });
+    const createIssue = tool({
+        description: 'Create a new GitHub issue. Use for tech debt, blockers, bugs, or follow-up work discovered during development.',
+        inputSchema: zodSchema(z.object({
+            title: z.string().describe('Issue title'),
+            body: z.string().describe('Issue body in markdown'),
+            labels: z.array(z.string()).default([]).describe('Labels to apply (e.g. bug, P0, tech-debt, blocker)'),
+        })),
+        execute: async ({ title, body, labels }) => {
+            try {
+                const args = [
+                    'issue', 'create',
+                    '--repo', `${owner}/${repo}`,
+                    '--title', title,
+                    '--body', body,
+                ];
+                for (const label of labels) {
+                    args.push('--label', label);
+                }
+                const stdout = await ghExec(args);
+                const url = stdout.trim();
+                const match = url.match(/\/(\d+)\s*$/);
+                return {
+                    success: true,
+                    issueNumber: match ? parseInt(match[1], 10) : undefined,
+                    url,
+                };
+            }
+            catch (err) {
+                return { success: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    });
+    const closeIssue = tool({
+        description: 'Close a GitHub issue. Use after verifying the work is actually shipped (PR merged, code on main).',
+        inputSchema: zodSchema(z.object({
+            issueNumber: z.number().int().describe('Issue number to close'),
+            comment: z.string().optional().describe('Optional closing comment'),
+        })),
+        execute: async ({ issueNumber, comment }) => {
+            try {
+                const args = [
+                    'issue', 'close', String(issueNumber),
+                    '--repo', `${owner}/${repo}`,
+                ];
+                if (comment)
+                    args.push('--comment', comment);
+                await ghExec(args);
+                return { success: true };
+            }
+            catch (err) {
+                return { success: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    });
+    const checkAllBoxes = tool({
+        description: 'Check all acceptance-criteria checkboxes in a GitHub issue body. Use after verifying all criteria are met.',
+        inputSchema: zodSchema(z.object({
+            issueNumber: z.number().int().describe('Issue number to update'),
+        })),
+        execute: async ({ issueNumber }) => {
+            try {
+                const body = await ghExec([
+                    'issue', 'view', String(issueNumber),
+                    '--repo', `${owner}/${repo}`,
+                    '--json', 'body', '--jq', '.body',
+                ]);
+                const updated = body.replace(/- \[ \]/g, '- [x]');
+                if (updated === body) {
+                    return { success: true, changed: false, message: 'No unchecked boxes found' };
+                }
+                await ghExec([
+                    'issue', 'edit', String(issueNumber),
+                    '--repo', `${owner}/${repo}`,
+                    '--body', updated,
+                ]);
+                const checked = (updated.match(/- \[x\]/gi) ?? []).length;
+                return { success: true, changed: true, totalChecked: checked };
+            }
+            catch (err) {
+                return { success: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    });
+    return { commentOnIssue, createIssue, closeIssue, checkAllBoxes };
+}

package/dist/agent/tools/schemas.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const FEATURE_NAME_SCHEMA: z.ZodString;

package/dist/agent/tools/schemas.js

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export const FEATURE_NAME_SCHEMA = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/).max(100)
+    .describe('Feature name (alphanumeric, hyphens, underscores)');

package/dist/agent/types.d.ts

@@ -0,0 +1,45 @@
+import type { LanguageModel } from 'ai';
+export type ReviewMode = 'manual' | 'auto' | 'merge';
+export interface AgentConfig {
+    model: LanguageModel;
+    modelId?: string;
+    provider?: string;
+    projectRoot: string;
+    owner: string;
+    repo: string;
+    maxSteps?: number;
+    maxItems?: number;
+    labels?: string[];
+    reviewMode?: ReviewMode;
+    dryRun?: boolean;
+    onStepUpdate?: (event: AgentStepEvent) => void;
+    onProgress?: (toolName: string, line: string) => void;
+}
+export interface AgentStepEvent {
+    toolCalls: Array<{
+        toolName: string;
+        args: unknown;
+    }>;
+    toolResults: Array<{
+        toolName: string;
+        result: unknown;
+    }>;
+    completedItems: number;
+}
+export interface AgentLogEntry {
+    timestamp: string;
+    message: string;
+    level: 'info' | 'warn' | 'error' | 'success';
+}
+export type AgentPhase = 'idle' | 'planning' | 'generating_spec' | 'running_loop' | 'reporting' | 'reflecting';
+export interface AgentIssueState {
+    issueNumber: number;
+    title: string;
+    labels: string[];
+    phase: AgentPhase;
+    loopPhase?: string;
+    loopFeatureName?: string;
+    loopIterations?: number;
+    prUrl?: string;
+    error?: string;
+}

package/dist/agent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ai/conversation/conversation-manager.js

@@ -150,6 +150,10 @@ Be concise but thorough. Focus on understanding the user's needs before proposin
             model,
             messages,
             ...(isReasoningModel(this.modelId) ? {} : { temperature: 0.7 }),
+            experimental_telemetry: {
+                isEnabled: true,
+                metadata: { agent: 'conversation-manager', provider: this.provider, model: this.modelId },
+            },
         };
         if (this.tools && Object.keys(this.tools).length > 0) {
             options.tools = this.tools;
@@ -192,6 +196,10 @@ Be concise but thorough. Focus on understanding the user's needs before proposin
             model,
             messages,
             ...(isReasoningModel(this.modelId) ? {} : { temperature: 0.7 }),
+            experimental_telemetry: {
+                isEnabled: true,
+                metadata: { agent: 'conversation-manager', provider: this.provider, model: this.modelId },
+            },
         });
         let fullResponse = '';
         for await (const textPart of result.textStream) {

package/dist/ai/conversation/url-fetcher.js

@@ -4,6 +4,7 @@
  */
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve, isAbsolute } from 'node:path';
+import { isGitHubIssueUrl, isGhInstalled, fetchGitHubIssue } from '../../utils/github.js';
 const MAX_CONTENT_LENGTH = 10000;
 const FETCH_TIMEOUT = 10000;
 /**
@@ -127,11 +128,37 @@ function readFromFile(filePath, projectRoot) {
         };
     }
 }
+/**
+ * Fetch GitHub issue content via gh CLI
+ */
+async function fetchGitHubContent(owner, repo, number) {
+    if (!(await isGhInstalled()))
+        return null;
+    const issue = await fetchGitHubIssue(owner, repo, number);
+    if (!issue)
+        return null;
+    let content = `# ${issue.title}\n\n${issue.body ?? ''}`;
+    const truncated = content.length > MAX_CONTENT_LENGTH;
+    if (truncated) {
+        content = content.slice(0, MAX_CONTENT_LENGTH) + '\n\n[Content truncated...]';
+    }
+    return {
+        source: `GitHub issue #${number}`,
+        content,
+        truncated,
+    };
+}
 /**
  * Fetch content from a URL or local file path
  */
 export async function fetchContent(input, projectRoot) {
     if (isUrl(input)) {
+        const ghIssue = isGitHubIssueUrl(input);
+        if (ghIssue) {
+            const result = await fetchGitHubContent(ghIssue.owner, ghIssue.repo, ghIssue.number);
+            if (result)
+                return result;
+        }
         return fetchFromUrl(input);
     }
     return readFromFile(input, projectRoot);

package/dist/ai/providers.js

@@ -35,12 +35,12 @@ export const KNOWN_API_KEYS = [
 export const AVAILABLE_MODELS = {
     anthropic: [
         { value: 'claude-opus-4-6', label: 'Claude Opus 4.6', hint: 'most capable' },
-        { value: 'claude-sonnet-4-5-20250929', label: 'Claude Sonnet 4.5', hint: 'recommended' },
+        { value: 'claude-sonnet-4-6', label: 'Claude Sonnet 4.6', hint: 'recommended' },
         { value: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', hint: 'fastest' },
     ],
     openai: [
         { value: 'gpt-5.2', label: 'GPT-5.2', hint: 'most capable' },
-        { value: 'gpt-5.2-codex', label: 'GPT-5.2 Codex', hint: 'best for code' },
+        { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex', hint: 'best for code' },
         { value: 'gpt-5.1', label: 'GPT-5.1', hint: 'previous gen' },
         { value: 'gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max', hint: 'previous codex' },
         { value: 'gpt-5-mini', label: 'GPT-5 Mini', hint: 'fastest' },
@@ -60,7 +60,7 @@ export const AVAILABLE_MODELS = {
  * Using balanced models for good results
  */
 const DEFAULT_MODELS = {
-    anthropic: 'claude-sonnet-4-5-20250929',
+    anthropic: 'claude-sonnet-4-6',
     openai: 'gpt-5.2',
     openrouter: 'google/gemini-3-pro-preview',
 };
@@ -68,7 +68,7 @@ const DEFAULT_MODELS = {
  * Anthropic shorthand aliases for legacy configs
  */
 const ANTHROPIC_MODEL_ALIASES = {
-    sonnet: 'claude-sonnet-4-5-20250929',
+    sonnet: 'claude-sonnet-4-6',
     opus: 'claude-opus-4-6',
     haiku: 'claude-haiku-4-5-20251001',
 };
@@ -177,7 +177,7 @@ const REASONING_MODELS = [
     'o3', 'o3-mini',
     'gpt-5', 'gpt-5.1', 'gpt-5-mini',
     'gpt-5.1-codex', 'gpt-5.1-codex-max',
-    'gpt-5.2', 'gpt-5.2-codex',
+    'gpt-5.2', 'gpt-5.3-codex',
 ];
 /**
  * Check if a model is a reasoning model that doesn't support temperature

package/dist/commands/agent.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Agent Command — Headless autonomous backlog executor
+ *
+ * Reads provider and model from ralph.config.cjs (set during wiggum init),
+ * detects GitHub remote, creates the agent orchestrator, and runs it
+ * in headless mode (generate or stream).
+ */
+export interface AgentOptions {
+    model?: string;
+    maxItems?: number;
+    maxSteps?: number;
+    labels?: string[];
+    reviewMode?: 'manual' | 'auto' | 'merge';
+    dryRun?: boolean;
+    stream?: boolean;
+}
+export declare function agentCommand(options?: AgentOptions): Promise<void>;

package/dist/commands/agent.js

@@ -0,0 +1,114 @@
+/**
+ * Agent Command — Headless autonomous backlog executor
+ *
+ * Reads provider and model from ralph.config.cjs (set during wiggum init),
+ * detects GitHub remote, creates the agent orchestrator, and runs it
+ * in headless mode (generate or stream).
+ */
+import { logger } from '../utils/logger.js';
+import { createAgentOrchestrator, } from '../agent/orchestrator.js';
+import { resolveAgentEnv } from '../agent/resolve-config.js';
+import { initTracing, flushTracing, traced, currentSpan } from '../utils/tracing.js';
+export async function agentCommand(options = {}) {
+    const projectRoot = process.cwd();
+    // Initialize Braintrust tracing (no-op if BRAINTRUST_API_KEY not set)
+    initTracing();
+    // Resolve provider, model, and GitHub remote
+    let env;
+    try {
+        env = await resolveAgentEnv(projectRoot, { model: options.model });
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    const { provider, model, modelId, owner, repo } = env;
+    // 4. Create orchestrator
+    const agentConfig = {
+        model,
+        modelId: modelId ?? undefined,
+        provider,
+        projectRoot,
+        owner,
+        repo,
+        maxSteps: options.maxSteps,
+        maxItems: options.maxItems,
+        labels: options.labels,
+        reviewMode: options.reviewMode,
+        dryRun: options.dryRun,
+        onStepUpdate: (event) => {
+            const log = options.stream
+                ? (msg) => process.stdout.write(`${msg}\n`)
+                : (msg) => logger.info(msg);
+            for (const tc of event.toolCalls) {
+                log(`[tool] ${tc.toolName}`);
+            }
+            for (const tr of event.toolResults) {
+                const summary = typeof tr.result === 'object' && tr.result !== null
+                    ? tr.result.status ?? tr.result.success ?? 'done'
+                    : 'done';
+                log(`[tool:done] ${tr.toolName} → ${summary}`);
+            }
+        },
+        onProgress: (toolName, line) => {
+            const log = options.stream
+                ? (msg) => process.stdout.write(`${msg}\n`)
+                : (msg) => logger.info(msg);
+            log(`  [${toolName}] ${line}`);
+        },
+    };
+    const agent = createAgentOrchestrator(agentConfig);
+    // 5. Run in headless mode
+    logger.info(`Agent starting: ${owner}/${repo} with ${provider}/${modelId ?? 'default'}`);
+    try {
+        await traced(async () => {
+            currentSpan().log({
+                input: {
+                    owner,
+                    repo,
+                    provider,
+                    model: modelId ?? 'default',
+                    maxItems: options.maxItems,
+                    maxSteps: options.maxSteps,
+                    labels: options.labels,
+                    dryRun: options.dryRun ?? false,
+                    stream: options.stream ?? false,
+                },
+                metadata: {
+                    command: 'agent',
+                    owner,
+                    repo,
+                    provider,
+                    model: modelId ?? 'default',
+                    dryRun: String(options.dryRun ?? false),
+                },
+                tags: ['agent'],
+            });
+            if (options.stream) {
+                const result = await agent.stream({ prompt: 'Begin working through the backlog.' });
+                let hasOutput = false;
+                for await (const chunk of result.textStream) {
+                    process.stdout.write(chunk);
+                    hasOutput = true;
+                }
+                if (hasOutput) {
+                    process.stdout.write('\n');
+                }
+            }
+            else {
+                const result = await agent.generate({ prompt: 'Begin working through the backlog.' });
+                if (result.text) {
+                    console.log(result.text);
+                }
+            }
+        }, { name: 'agent-run' });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: Agent failed — ${message}`);
+        process.exit(1);
+    }
+    finally {
+        await flushTracing();
+    }
+}