@proletariat/cli 0.3.35 → 0.3.40

package/dist/commands/session/peek.js

@@ -0,0 +1,316 @@
+import { Args, Flags } from '@oclif/core';
+import * as path from 'node:path';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/index.js';
+import { parseSessionName, getHostTmuxSessionNames, getContainerTmuxSessionMap, flattenContainerSessions, findContainerSessionsByPrefix, findSessionForExecution, captureTmuxPane, } from '../../lib/execution/session-utils.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+// =============================================================================
+// Command
+// =============================================================================
+export default class SessionPeek extends PMOCommand {
+    static description = 'View agent tmux pane content without attaching (non-interactive)';
+    static examples = [
+        '<%= config.bin %> session peek altman',
+        '<%= config.bin %> session peek TKT-123',
+        '<%= config.bin %> session peek WORK-ABCD1234',
+        '<%= config.bin %> session peek altman --lines 100',
+        '<%= config.bin %> session peek TKT-123 --json',
+        '<%= config.bin %> session peek altman | grep error',
+    ];
+    static args = {
+        target: Args.string({
+            description: 'Agent name, ticket ID (e.g. TKT-123), or execution ID (e.g. WORK-XXXXXXXX)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        lines: Flags.integer({
+            char: 'l',
+            description: 'Number of scrollback lines to capture',
+            default: 50,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SessionPeek);
+        const jsonMode = shouldOutputJson(flags);
+        // Discover all verified sessions
+        const sessions = this.getVerifiedSessions();
+        if (sessions.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_SESSIONS', 'No active sessions found.', createMetadata('session peek', flags));
+                return;
+            }
+            this.log('');
+            this.log(styles.muted('No active sessions found.'));
+            this.log('');
+            this.log(styles.muted('Start work with: prlt work start <ticket-id>'));
+            this.log('');
+            return;
+        }
+        if (args.target) {
+            // Resolve target to matching session(s)
+            const matched = this.resolveTarget(args.target, sessions);
+            if (matched.length === 0) {
+                if (jsonMode) {
+                    outputErrorAsJson('SESSION_NOT_FOUND', `No matching session found for "${args.target}".`, createMetadata('session peek', flags));
+                    return;
+                }
+                this.error(`No matching session found for "${args.target}". Run "prlt session list" to see available sessions.`);
+            }
+            // Output all matched sessions
+            if (jsonMode && matched.length > 1) {
+                // Collect all captures into a single JSON response
+                const results = matched.map(session => {
+                    const containerId = session.environment === 'container' ? session.containerId : undefined;
+                    const content = captureTmuxPane(session.sessionId, flags.lines, containerId);
+                    return {
+                        sessionId: session.sessionId,
+                        ticketId: session.ticketId,
+                        agentName: session.agentName,
+                        environment: session.environment,
+                        containerId: session.containerId,
+                        lines: flags.lines,
+                        content,
+                        captureError: content === null
+                            ? `Failed to capture pane content for session "${session.sessionId}".`
+                            : undefined,
+                    };
+                });
+                outputSuccessAsJson({ sessions: results }, createMetadata('session peek', flags));
+                return;
+            }
+            for (const session of matched) {
+                this.outputPeek(session, flags.lines, jsonMode, flags);
+            }
+        }
+        else {
+            // No target: interactive selection
+            const selected = await this.selectFromList({
+                message: 'Select a session to peek at:',
+                items: sessions,
+                getName: (s) => `${s.sessionId} (${s.ticketId}) - ${s.agentName} [${s.environment}]`,
+                getValue: (s) => s.sessionId,
+                getCommand: (s) => `prlt session peek "${s.sessionId}" --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'session peek' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            const session = sessions.find(s => s.sessionId === selected);
+            if (!session) {
+                this.error('No session selected');
+            }
+            this.outputPeek(session, flags.lines, jsonMode, flags);
+        }
+    }
+    /**
+     * Resolve a target identifier to matching sessions.
+     * Supports: agent name, ticket ID (TKT-XXX), execution ID (WORK-XXX), or session ID.
+     */
+    resolveTarget(target, sessions) {
+        // Try exact session ID match
+        const exactSession = sessions.filter(s => s.sessionId === target);
+        if (exactSession.length > 0)
+            return exactSession;
+        // Try ticket ID match (e.g. TKT-123)
+        if (/^[A-Z]+-\d+$/i.test(target)) {
+            const ticketTarget = target.toUpperCase();
+            const ticketMatches = sessions.filter(s => s.ticketId === ticketTarget);
+            if (ticketMatches.length > 0)
+                return ticketMatches;
+        }
+        // Try execution ID match (WORK-XXX) — resolve via DB to find session
+        if (target.toUpperCase().startsWith('WORK-')) {
+            const executionMatch = this.resolveFromExecution(target.toUpperCase(), sessions);
+            if (executionMatch.length > 0)
+                return executionMatch;
+        }
+        // Try agent name match
+        const agentMatches = sessions.filter(s => s.agentName === target);
+        if (agentMatches.length > 0)
+            return agentMatches;
+        // Try partial session ID match
+        const partialMatches = sessions.filter(s => s.sessionId.includes(target) ||
+            s.ticketId.includes(target.toUpperCase()) ||
+            s.agentName.includes(target));
+        return partialMatches;
+    }
+    /**
+     * Resolve an execution ID (WORK-XXX) to matching sessions.
+     */
+    resolveFromExecution(executionId, sessions) {
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            const executionStorage = new ExecutionStorage(db);
+            const execution = executionStorage.getExecution(executionId);
+            if (execution) {
+                return sessions.filter(s => s.ticketId === execution.ticketId && s.agentName === execution.agentName);
+            }
+        }
+        catch {
+            // Workspace not available
+        }
+        finally {
+            db?.close();
+        }
+        return [];
+    }
+    /**
+     * Output peek content for a session.
+     * In raw mode: outputs plain text to stdout.
+     * In JSON mode: outputs structured JSON.
+     */
+    outputPeek(session, lines, jsonMode, flags) {
+        const containerId = session.environment === 'container' ? session.containerId : undefined;
+        const content = captureTmuxPane(session.sessionId, lines, containerId);
+        if (content === null) {
+            if (jsonMode) {
+                outputErrorAsJson('CAPTURE_FAILED', `Failed to capture pane content for session "${session.sessionId}". The session may no longer exist or tmux may not be available.`, createMetadata('session peek', flags));
+                return;
+            }
+            this.error(`Failed to capture pane content for session "${session.sessionId}". ` +
+                'The session may no longer exist or tmux may not be available.');
+        }
+        if (jsonMode) {
+            outputSuccessAsJson({
+                sessionId: session.sessionId,
+                ticketId: session.ticketId,
+                agentName: session.agentName,
+                environment: session.environment,
+                containerId: session.containerId,
+                lines,
+                content,
+            }, createMetadata('session peek', flags));
+        }
+        else {
+            // Raw text output — pipeable and scriptable
+            process.stdout.write(content + '\n');
+        }
+    }
+    /**
+     * Get verified sessions from DB that have actual tmux processes.
+     * Same discovery pattern as attach.ts and list.ts.
+     */
+    getVerifiedSessions() {
+        const sessions = [];
+        let executionStorage = null;
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+        }
+        catch {
+            // Not in workspace — can still discover tmux sessions
+        }
+        try {
+            const hostTmuxSessions = getHostTmuxSessionNames();
+            const containerTmuxSessions = getContainerTmuxSessionMap();
+            const allContainerSessions = flattenContainerSessions(containerTmuxSessions);
+            const matchedHostSessions = new Set();
+            const matchedContainerSessions = new Set();
+            // Get active executions from DB
+            const activeExecutions = executionStorage ? [
+                ...(executionStorage.listExecutions({ status: 'running' }) || []),
+                ...(executionStorage.listExecutions({ status: 'starting' }) || []),
+            ] : [];
+            for (const exec of activeExecutions) {
+                const isContainer = exec.environment === 'devcontainer';
+                let exists = false;
+                let containerId;
+                let actualSessionId = exec.sessionId;
+                if (!exec.sessionId) {
+                    if (isContainer && exec.containerId) {
+                        const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
+                        const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
+                        if (match) {
+                            actualSessionId = match;
+                            exists = true;
+                            containerId = exec.containerId;
+                        }
+                    }
+                    else {
+                        const match = findSessionForExecution(exec.ticketId, exec.agentName, hostTmuxSessions);
+                        if (match) {
+                            actualSessionId = match;
+                            exists = true;
+                        }
+                    }
+                    if (!actualSessionId)
+                        continue;
+                }
+                else {
+                    if (isContainer && exec.containerId) {
+                        const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
+                        exists = containerSessions.includes(exec.sessionId);
+                        containerId = exec.containerId;
+                    }
+                    else {
+                        exists = hostTmuxSessions.includes(exec.sessionId);
+                    }
+                }
+                if (exists && actualSessionId) {
+                    if (isContainer && containerId) {
+                        matchedContainerSessions.add(`${containerId}:${actualSessionId}`);
+                    }
+                    else {
+                        matchedHostSessions.add(actualSessionId);
+                    }
+                    sessions.push({
+                        sessionId: actualSessionId,
+                        ticketId: exec.ticketId,
+                        agentName: exec.agentName,
+                        environment: isContainer ? 'container' : 'host',
+                        containerId,
+                        source: 'db',
+                    });
+                }
+            }
+            // Discover orphan sessions matching prlt pattern
+            for (const sessionName of hostTmuxSessions) {
+                if (matchedHostSessions.has(sessionName))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        environment: 'host',
+                        source: 'discovered',
+                    });
+                }
+            }
+            for (const { sessionName, containerId } of allContainerSessions) {
+                if (matchedContainerSessions.has(`${containerId}:${sessionName}`))
+                    continue;
+                const parsed = parseSessionName(sessionName);
+                if (parsed) {
+                    sessions.push({
+                        sessionId: sessionName,
+                        ticketId: parsed.ticketId,
+                        agentName: parsed.agentName,
+                        environment: 'container',
+                        containerId,
+                        source: 'discovered',
+                    });
+                }
+            }
+        }
+        finally {
+            db?.close();
+        }
+        return sessions;
+    }
+}

package/dist/commands/session/poke.d.ts

@@ -0,0 +1,27 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionPoke extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agent: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        message: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Resolve an agent identifier (name or ticket ID) to a running session.
+     * Looks up active executions and matches tmux sessions.
+     */
+    private resolveAgentSession;
+    /**
+     * Resolve the tmux session for a specific execution record.
+     */
+    private resolveSessionForExecution;
+}

package/dist/commands/session/poke.js

@@ -0,0 +1,219 @@
+import { Args } from '@oclif/core';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import Database from 'better-sqlite3';
+import { styles } from '../../lib/styles.js';
+import { getWorkspaceInfo } from '../../lib/agents/commands.js';
+import { ExecutionStorage } from '../../lib/execution/index.js';
+import { getHostTmuxSessionNames, getContainerTmuxSessionMap, findContainerSessionsByPrefix, findSessionForExecution, } from '../../lib/execution/session-utils.js';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+// =============================================================================
+// tmux Helpers
+// =============================================================================
+/**
+ * Send a text message to a tmux session via send-keys.
+ * Sends the text first, then Enter separately with a small delay
+ * to avoid race conditions where Enter arrives before text is rendered.
+ */
+function sendMessage(sessionId, message, containerId) {
+    // Escape single quotes in the message for shell safety
+    const escapedMessage = message.replace(/'/g, "'\\''");
+    // Send the text first (without Enter), using -l (literal) flag so tmux
+    // does not interpret special characters - message is delivered verbatim
+    const sendTextCmd = `tmux send-keys -l -t "${sessionId}" '${escapedMessage}'`;
+    // Then send Enter separately (Enter is a tmux key name, not literal text)
+    const sendEnterCmd = `tmux send-keys -t "${sessionId}" Enter`;
+    if (containerId) {
+        execSync(`docker exec ${containerId} bash -c '${sendTextCmd}'`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 });
+        // Small delay before sending Enter to avoid race conditions
+        execSync('sleep 0.1', { stdio: ['pipe', 'pipe', 'pipe'] });
+        execSync(`docker exec ${containerId} bash -c '${sendEnterCmd}'`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10000 });
+    }
+    else {
+        execSync(sendTextCmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        });
+        // Small delay before sending Enter
+        execSync('sleep 0.1', { stdio: ['pipe', 'pipe', 'pipe'] });
+        execSync(sendEnterCmd, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+        });
+    }
+}
+// =============================================================================
+// Command
+// =============================================================================
+export default class SessionPoke extends PMOCommand {
+    static description = 'Send a message to a running agent\'s Claude Code session';
+    static examples = [
+        '<%= config.bin %> session poke altman "Please focus on the tests first"',
+        '<%= config.bin %> session poke TKT-123 "Add error handling for edge cases"',
+    ];
+    static args = {
+        agent: Args.string({
+            description: 'Agent name or ticket ID of the running agent',
+            required: true,
+        }),
+        message: Args.string({
+            description: 'Message to send to the agent session',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SessionPoke);
+        const jsonMode = shouldOutputJson(flags);
+        const { agent, message } = args;
+        // Resolve the agent's active session
+        const resolved = this.resolveAgentSession(agent, jsonMode, flags);
+        if (!resolved)
+            return;
+        // Send the message
+        try {
+            sendMessage(resolved.sessionId, message, resolved.containerId);
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            // Check for specific container/session errors
+            if (errMsg.includes('no server running') || errMsg.includes('session not found') || errMsg.includes("can't find session")) {
+                if (jsonMode) {
+                    outputErrorAsJson('SESSION_NOT_FOUND', `tmux session "${resolved.sessionId}" does not exist. The agent may have exited.`, createMetadata('session poke', flags));
+                }
+                this.log('');
+                this.log(styles.error(`tmux session "${resolved.sessionId}" does not exist. The agent may have exited.`));
+                this.log(styles.muted('Use `prlt session list` to see running sessions.'));
+                this.log('');
+                return;
+            }
+            if (errMsg.includes('No such container') || errMsg.includes('is not running')) {
+                if (jsonMode) {
+                    outputErrorAsJson('CONTAINER_NOT_RUNNING', `Docker container for agent "${resolved.agentName}" is not running.`, createMetadata('session poke', flags));
+                }
+                this.log('');
+                this.log(styles.error(`Docker container for agent "${resolved.agentName}" is not running.`));
+                this.log(styles.muted('The container may have stopped. Check with `docker ps`.'));
+                this.log('');
+                return;
+            }
+            // Generic send failure
+            if (jsonMode) {
+                outputErrorAsJson('SEND_FAILED', `Failed to send message to agent "${resolved.agentName}": ${errMsg}`, createMetadata('session poke', flags));
+            }
+            this.log('');
+            this.log(styles.error(`Failed to send message: ${errMsg}`));
+            this.log('');
+            return;
+        }
+        // Output result
+        if (jsonMode) {
+            outputSuccessAsJson({
+                success: true,
+                agent: resolved.agentName,
+                session: resolved.sessionId,
+                message,
+            }, createMetadata('session poke', flags));
+        }
+        this.log('');
+        this.log(styles.success(`Message sent to ${resolved.agentName} (${resolved.ticketId})`));
+        this.log('');
+    }
+    /**
+     * Resolve an agent identifier (name or ticket ID) to a running session.
+     * Looks up active executions and matches tmux sessions.
+     */
+    resolveAgentSession(identifier, jsonMode, flags) {
+        let executionStorage = null;
+        let db = null;
+        try {
+            const workspaceInfo = getWorkspaceInfo();
+            const dbPath = path.join(workspaceInfo.path, '.proletariat', 'workspace.db');
+            db = new Database(dbPath);
+            executionStorage = new ExecutionStorage(db);
+        }
+        catch {
+            if (jsonMode) {
+                outputErrorAsJson('NOT_IN_WORKSPACE', 'Not in a workspace. Run from a proletariat HQ directory.', createMetadata('session poke', flags));
+            }
+            this.log('');
+            this.log(styles.error('Not in a workspace. Run from a proletariat HQ directory.'));
+            this.log('');
+            return null;
+        }
+        try {
+            // Get active executions
+            const runningExecutions = executionStorage.listExecutions({ status: 'running' });
+            const startingExecutions = executionStorage.listExecutions({ status: 'starting' });
+            const activeExecutions = [...runningExecutions, ...startingExecutions];
+            // Find matching execution by exact agent name or exact ticket ID
+            const match = activeExecutions.find(exec => exec.agentName === identifier || exec.ticketId === identifier);
+            if (!match) {
+                if (jsonMode) {
+                    outputErrorAsJson('NO_ACTIVE_EXECUTION', `Agent "${identifier}" has no active session. Use \`prlt session list\` to see running sessions.`, createMetadata('session poke', flags));
+                }
+                this.log('');
+                this.log(styles.error(`Agent "${identifier}" has no active session.`));
+                this.log(styles.muted('Use `prlt session list` to see running sessions.'));
+                this.log('');
+                return null;
+            }
+            return this.resolveSessionForExecution(match, jsonMode, flags);
+        }
+        finally {
+            db?.close();
+        }
+    }
+    /**
+     * Resolve the tmux session for a specific execution record.
+     */
+    resolveSessionForExecution(exec, jsonMode, flags) {
+        const isContainer = exec.environment === 'devcontainer';
+        let actualSessionId = exec.sessionId;
+        let containerId = isContainer ? exec.containerId : undefined;
+        // If sessionId is NULL, try to discover it from tmux
+        if (!exec.sessionId) {
+            if (isContainer && exec.containerId) {
+                const containerTmuxSessions = getContainerTmuxSessionMap();
+                const containerSessions = findContainerSessionsByPrefix(containerTmuxSessions, exec.containerId);
+                const match = findSessionForExecution(exec.ticketId, exec.agentName, containerSessions);
+                if (match) {
+                    actualSessionId = match;
+                    containerId = exec.containerId;
+                }
+            }
+            else {
+                const hostTmuxSessions = getHostTmuxSessionNames();
+                const match = findSessionForExecution(exec.ticketId, exec.agentName, hostTmuxSessions);
+                if (match) {
+                    actualSessionId = match;
+                }
+            }
+        }
+        if (!actualSessionId) {
+            if (jsonMode) {
+                outputErrorAsJson('SESSION_NOT_FOUND', `Could not find tmux session for agent "${exec.agentName}" (${exec.ticketId}). The session may not have started yet.`, createMetadata('session poke', flags));
+            }
+            this.log('');
+            this.log(styles.error(`Could not find tmux session for agent "${exec.agentName}" (${exec.ticketId}).`));
+            this.log(styles.muted('The session may not have started yet.'));
+            this.log('');
+            return null;
+        }
+        return {
+            sessionId: actualSessionId,
+            ticketId: exec.ticketId,
+            agentName: exec.agentName,
+            environment: isContainer ? 'container' : 'host',
+            containerId,
+        };
+    }
+}

package/dist/commands/spec/view.js

@@ -83,6 +83,35 @@ export default class SpecView extends PMOCommand {
         // Get dependencies
         const dependencies = await this.storage.getSpecDependencies(spec.id);
         const dependents = await this.storage.getSpecDependents(spec.id);
+        // JSON output mode
+        if (jsonMode) {
+            this.log(JSON.stringify({
+                success: true,
+                spec: {
+                    id: spec.id,
+                    title: spec.title,
+                    status: spec.status,
+                    type: spec.type,
+                    problem: spec.problem,
+                    solution: spec.solution,
+                    decisions: spec.decisions,
+                    notNow: spec.notNow,
+                    uiUx: spec.uiUx,
+                    acceptanceCriteria: spec.acceptanceCriteria,
+                    openQuestions: spec.openQuestions,
+                    requirementsFunctional: spec.requirementsFunctional,
+                    requirementsTechnical: spec.requirementsTechnical,
+                    context: spec.context,
+                    tags: spec.tags,
+                    createdAt: spec.createdAt.toISOString(),
+                    updatedAt: spec.updatedAt.toISOString(),
+                    dependencies: dependencies.map(d => ({ id: d.id, title: d.title, status: d.status })),
+                    dependents: dependents.map(d => ({ id: d.id, title: d.title, status: d.status })),
+                    tickets: tickets.map(t => ({ id: t.id, title: t.title, status: t.status })),
+                },
+            }, null, 2));
+            return;
+        }
         // Display spec info
         this.log(styles.title(`\n📄 ${spec.title}`));
         this.log(styles.muted('═'.repeat(60)));

package/dist/commands/template/list.js

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 import { styles } from '../../lib/styles.js';
 export default class TemplateList extends PMOCommand {
     static description = 'List all templates (ticket and phase)';
@@ -44,7 +45,7 @@ export default class TemplateList extends PMOCommand {
             showTicket ? this.storage.listTicketTemplates(builtinFilter) : Promise.resolve([]),
             showPhase ? this.storage.listPhaseTemplates(builtinFilter) : Promise.resolve([]),
         ]);
-        if (flags.json || flags.machine) {
+        if (shouldOutputJson(flags)) {
             const result = {};
             if (showTicket)
                 result.ticket = ticketTemplates;

package/dist/commands/theme/add-names.d.ts

@@ -2,6 +2,10 @@ import { Command } from '@oclif/core';
 export default class ThemeAddNames extends Command {
     static description: string;
     static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     static args: {
         theme: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
         names: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/theme/add-names.js

@@ -3,12 +3,17 @@ import chalk from 'chalk';
 import { getWorkspaceInfo } from '../../lib/agents/commands.js';
 import { isValidAgentName, normalizeAgentName } from '../../lib/themes.js';
 import { getTheme, addThemeNames, getThemeNames } from '../../lib/database/index.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class ThemeAddNames extends Command {
     static description = 'Add names to a theme';
     static examples = [
         '<%= config.bin %> <%= command.id %> greek-gods zeus athena poseidon',
         '<%= config.bin %> <%= command.id %> my-theme agent-a agent-b',
     ];
+    static flags = {
+        ...machineOutputFlags,
+    };
     static args = {
         theme: Args.string({
             description: 'Theme ID',
@@ -21,7 +26,8 @@ export default class ThemeAddNames extends Command {
     };
     static strict = false; // Allow multiple name arguments
     async run() {
-        const { args, argv } = await this.parse(ThemeAddNames);
+        const { args, argv, flags } = await this.parse(ThemeAddNames);
+        const jsonMode = shouldOutputJson(flags);
         try {
             const workspaceInfo = getWorkspaceInfo();
             // Validate theme exists
@@ -60,6 +66,10 @@ export default class ThemeAddNames extends Command {
             addThemeNames(workspaceInfo.path, theme.id, validNames);
             // Get updated count
             const allNames = getThemeNames(workspaceInfo.path, theme.id);
+            if (jsonMode) {
+                this.log(JSON.stringify({ type: 'success', result: { theme: args.theme, added: validNames, totalNames: allNames.length } }, null, 2));
+                return;
+            }
             this.log(chalk.green(`\n Added ${validNames.length} name(s) to ${theme.display_name}:`));
             this.log(chalk.gray(`   ${validNames.join(', ')}`));
             this.log(chalk.gray(`\n   Theme now has ${allNames.length} names total.`));

package/dist/commands/theme/create.d.ts

@@ -8,6 +8,8 @@ export default class ThemeCreate extends Command {
     static flags: {
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'display-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }