@proletariat/cli 0.1.4 → 0.3.0

package/dist/commands/repo/remove.js

@@ -0,0 +1,217 @@
+import { Args, Flags } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import inquirer from 'inquirer';
+import { colors, format } from '../../lib/colors.js';
+import { findHQRoot, promptSelectMultipleRepos, removeRepository, getWorkspaceRepoInfo } from '../../lib/repos/index.js';
+import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+export default class Remove extends PMOCommand {
+    static description = 'Remove a repository from the HQ';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-repo',
+        '<%= config.bin %> <%= command.id %> my-repo --force',
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --bulk',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Repository name to remove',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+        'keep-files': Flags.boolean({
+            description: 'Remove from database but keep files',
+            default: false,
+        }),
+        bulk: Flags.boolean({
+            char: 'b',
+            description: 'Remove multiple repositories interactively',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(Remove);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('repo remove', flags));
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Find HQ root
+        const hqPath = findHQRoot();
+        if (!hqPath) {
+            return handleError('NOT_IN_HQ', 'Not in an HQ directory. Run "prlt init" first.');
+        }
+        // Bulk mode: remove multiple repositories interactively
+        if (flags.bulk) {
+            await this.executeBulk(hqPath, flags.force, flags['keep-files'], jsonMode, flags);
+            return;
+        }
+        let repoName = args.name || null;
+        // Interactive selection if no name provided
+        if (!repoName) {
+            const { repositories } = getWorkspaceRepoInfo();
+            if (repositories.length === 0) {
+                return handleError('NO_REPOSITORIES', 'No repositories found.');
+            }
+            // Build choices once, use for both JSON and interactive modes
+            const repoChoices = repositories.map(r => ({
+                name: r.name,
+                value: r.name,
+            }));
+            const selectMessage = 'Select repository to remove:';
+            // In JSON mode, output repo selection prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'repoName', selectMessage, repoChoices), createMetadata('repo remove', flags));
+                return;
+            }
+            const { selected } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selected',
+                    message: selectMessage,
+                    choices: repoChoices,
+                }]);
+            repoName = selected;
+            if (!repoName) {
+                this.log(colors.textMuted('Operation cancelled.'));
+                return;
+            }
+        }
+        // Validate repository exists
+        const { repositories } = getWorkspaceRepoInfo();
+        const repo = repositories.find(r => r.name === repoName);
+        if (!repo) {
+            return handleError('REPO_NOT_FOUND', `Repository "${repoName}" not found.`);
+        }
+        // Confirmation unless --force
+        if (!flags.force) {
+            // Build choices once, use for both JSON and interactive modes
+            const confirmChoices = [
+                { name: 'No, cancel', value: 'false' },
+                { name: 'Yes, remove repository', value: 'true' },
+            ];
+            const confirmMessage = `Remove repository "${repoName}"? (This will remove repos/${repoName} directory and agent worktrees)`;
+            // In JSON mode, output confirmation prompt
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'confirmed', confirmMessage, confirmChoices), createMetadata('repo remove', flags));
+                return;
+            }
+            this.log(colors.warning('\n⚠️  This will:'));
+            this.log(colors.text(`  • Remove repos/${repoName} directory`));
+            this.log(colors.text('  • Remove agent worktrees for this repo'));
+            this.log(colors.text('  • Update database\n'));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: `Are you sure you want to remove "${repoName}"?`,
+                    choices: [
+                        { name: '❌ ' + confirmChoices[0].name, value: false },
+                        { name: '⚠️  ' + confirmChoices[1].name, value: true }
+                    ],
+                    default: 0
+                }]);
+            if (!confirm) {
+                this.log(colors.textMuted('Removal cancelled.'));
+                return;
+            }
+        }
+        // Remove the repository
+        this.log(colors.primary(`\nRemoving repository "${repoName}"...`));
+        const result = await removeRepository(hqPath, repoName, flags['keep-files']);
+        if (result.success) {
+            this.log(format.success(`Repository ${repoName} removed`));
+        }
+        else {
+            this.error(`Failed to remove repository: ${result.error}`);
+        }
+    }
+    /**
+     * Bulk mode: remove multiple repositories interactively
+     */
+    async executeBulk(hqPath, force, keepFiles, jsonMode = false, flags = {}) {
+        // In JSON mode, output repo selection prompt for bulk mode
+        if (jsonMode) {
+            const { repositories } = getWorkspaceRepoInfo();
+            if (repositories.length === 0) {
+                outputErrorAsJson('NO_REPOSITORIES', 'No repositories found.', createMetadata('repo remove', flags));
+                this.exit(1);
+            }
+            const repoChoices = repositories.map(r => ({
+                name: r.name,
+                value: r.name,
+            }));
+            outputPromptAsJson(buildPromptConfig('checkbox', 'repoNames', 'Select repositories to remove:', repoChoices), createMetadata('repo remove', flags));
+            return;
+        }
+        this.log(colors.primary('📦 Remove Repositories (Bulk Mode)\n'));
+        // Select repositories to remove
+        const selectedRepos = await promptSelectMultipleRepos('Select repositories to remove:');
+        if (selectedRepos.length === 0) {
+            this.log(colors.textMuted('No repositories selected.'));
+            return;
+        }
+        // Confirmation unless --force
+        if (!force) {
+            this.log(colors.warning('\n⚠️  This will permanently delete:'));
+            for (const name of selectedRepos) {
+                this.log(colors.text(`  • repos/${name}`));
+            }
+            this.log(colors.text('  • Agent worktrees for these repos\n'));
+            const { confirm } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Are you sure?',
+                    choices: [
+                        { name: '❌ No, cancel', value: false },
+                        { name: '⚠️  Yes, remove repositories', value: true }
+                    ],
+                    default: 0
+                }]);
+            if (!confirm) {
+                this.log(colors.textMuted('Removal cancelled.'));
+                return;
+            }
+        }
+        this.log('');
+        // Remove each repository
+        let successCount = 0;
+        let failCount = 0;
+        for (const repoName of selectedRepos) {
+            this.log(colors.textMuted(`Removing ${repoName}...`));
+            const result = await removeRepository(hqPath, repoName, keepFiles);
+            if (result.success) {
+                this.log(format.success(`Removed ${repoName}`));
+                successCount++;
+            }
+            else {
+                this.log(format.error(`Failed to remove ${repoName}: ${result.error}`));
+                failCount++;
+            }
+        }
+        // Summary
+        this.log('');
+        if (successCount > 0) {
+            this.log(format.success(`Removed ${successCount} repository(ies)`));
+        }
+        if (failCount > 0) {
+            this.log(format.error(`Failed to remove ${failCount} repository(ies)`));
+        }
+    }
+}

package/dist/commands/repo/view.d.ts

@@ -0,0 +1,15 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class View extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}

package/dist/commands/repo/view.js

@@ -0,0 +1,99 @@
+import { Args } from '@oclif/core';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors, format } from '../../lib/colors.js';
+import { findHQRoot, promptSelectRepo, getWorkspaceRepoInfo, } from '../../lib/repos/index.js';
+import { openWorkspaceDatabase } from '../../lib/database/index.js';
+export default class View extends PMOCommand {
+    static description = 'View detailed information about a repository';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> my-repo',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Repository name to view',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args } = await this.parse(View);
+        // Find HQ root
+        const hqPath = findHQRoot();
+        if (!hqPath) {
+            this.error('Not in an HQ directory. Run "prlt init" first.');
+        }
+        let repoName = args.name || null;
+        // Interactive selection if no name provided
+        if (!repoName) {
+            repoName = await promptSelectRepo('Select repository to view:');
+            if (!repoName) {
+                this.log(colors.textMuted('Operation cancelled.'));
+                return;
+            }
+        }
+        // Get repository info
+        const { repositories } = getWorkspaceRepoInfo();
+        const repo = repositories.find(r => r.name === repoName);
+        if (!repo) {
+            this.error(`Repository "${repoName}" not found.`);
+        }
+        // Display repository details
+        this.log(format.title(`📦 Repository: ${repo.name}`));
+        this.log('');
+        this.log(`Path:        ${colors.path(repo.path)}`);
+        if (repo.sourceUrl) {
+            this.log(`Source:      ${colors.text(repo.sourceUrl)}`);
+        }
+        if (repo.addedAt) {
+            this.log(`Added:       ${colors.text(new Date(repo.addedAt).toLocaleString())}`);
+        }
+        this.log(format.subtitle('\n📊 Git Status:'));
+        if (repo.status === 'missing') {
+            this.log(colors.error('  Repository directory not found'));
+        }
+        else {
+            const statusIcon = repo.status === 'clean' ? '🟢' : '🟡';
+            const statusColor = repo.status === 'clean' ? colors.success : colors.warning;
+            this.log(`  Branch:    ${colors.warning(repo.branch || 'unknown')}`);
+            this.log(`  Status:    ${statusIcon} ${statusColor(repo.status)}`);
+            if (repo.commitsAhead > 0 || repo.commitsBehind > 0) {
+                let commitInfo = '';
+                if (repo.commitsAhead > 0) {
+                    commitInfo += `${repo.commitsAhead} ahead`;
+                }
+                if (repo.commitsBehind > 0) {
+                    if (commitInfo)
+                        commitInfo += ', ';
+                    commitInfo += `${repo.commitsBehind} behind`;
+                }
+                this.log(`  Commits:   ${colors.text(commitInfo)}`);
+            }
+        }
+        // Get agent worktree info
+        const db = openWorkspaceDatabase(hqPath);
+        const worktrees = db.prepare(`
+      SELECT agent_name, is_clean, commits_ahead, branch
+      FROM agent_worktrees
+      WHERE repo_name = ?
+    `).all(repoName);
+        db.close();
+        if (worktrees.length > 0) {
+            this.log(format.subtitle('\n👥 Agent Worktrees:'));
+            for (const wt of worktrees) {
+                const wtStatus = wt.is_clean ? 'clean' : 'dirty';
+                const wtColor = wt.is_clean ? colors.repoClean : colors.repoDirty;
+                let line = `  • ${colors.agentName(wt.agent_name.padEnd(10))} - ${wtColor(wtStatus)}`;
+                if (wt.commits_ahead > 0) {
+                    line += colors.commitsAhead(` (${wt.commits_ahead} ahead)`);
+                }
+                this.log(line);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+export default class SessionAttach extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        session: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'new-tab': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'current-terminal': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        terminal: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+    /**
+     * Get verified sessions from DB that have actual tmux processes
+     * DB-driven approach: Start with executions, verify tmux sessions exist
+     */
+    private getVerifiedSessions;
+    /**
+     * Get list of host tmux session names
+     */
+    private getHostTmuxSessionNames;
+    /**
+     * Get map of containerId -> tmux session names
+     */
+    private getContainerTmuxSessionMap;
+    /**
+     * Attach to session in current terminal
+     */
+    private attachInCurrentTerminal;
+    /**
+     * Attach to session in a new terminal tab
+     */
+    private attachInNewTab;
+}

package/dist/commands/session/attach.js

@@ -0,0 +1,307 @@
+import { Args, Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+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 { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+export default class SessionAttach extends PMOCommand {
+    static description = 'Attach to an active tmux session';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> TKT-347-implement-altman',
+        '<%= config.bin %> <%= command.id %> --current-terminal',
+    ];
+    static args = {
+        session: Args.string({
+            description: 'Session name or ticket ID to attach to (optional - will prompt if not provided)',
+            required: false,
+        }),
+    };
+    static flags = {
+        ...pmoBaseFlags,
+        json: Flags.boolean({
+            description: 'Output prompt configuration as JSON (for AI agents/scripts)',
+            default: false,
+        }),
+        'new-tab': Flags.boolean({
+            char: 'n',
+            description: 'Open in a new terminal tab (default: true)',
+            default: true,
+        }),
+        'current-terminal': Flags.boolean({
+            char: 'c',
+            description: 'Attach in current terminal instead of new tab',
+            default: false,
+        }),
+        terminal: Flags.string({
+            char: 't',
+            description: 'Terminal app to use (iTerm, Terminal, Ghostty)',
+            default: 'iTerm',
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { args, flags } = await this.parse(SessionAttach);
+        // Check if JSON output mode is active
+        const jsonMode = shouldOutputJson(flags);
+        // Get all available sessions (DB-driven)
+        const sessions = this.getVerifiedSessions();
+        if (sessions.length === 0) {
+            if (jsonMode) {
+                outputErrorAsJson('NO_SESSIONS', 'No active sessions found.', createMetadata('session attach', 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;
+        }
+        // Determine which session to attach to
+        let selectedSession;
+        if (args.session) {
+            // Find session by name, sessionId, or ticketId (partial match)
+            selectedSession = sessions.find(s => s.sessionId === args.session ||
+                s.sessionId.includes(args.session) ||
+                s.ticketId === args.session ||
+                s.ticketId.includes(args.session));
+            if (!selectedSession) {
+                if (jsonMode) {
+                    outputErrorAsJson('SESSION_NOT_FOUND', `Session "${args.session}" not found.`, createMetadata('session attach', flags));
+                    return;
+                }
+                this.error(`Session "${args.session}" not found. Run "prlt session list" to see available sessions.`);
+            }
+        }
+        else {
+            // Use selectFromList helper for session selection
+            const selected = await this.selectFromList({
+                message: 'Select a session to attach to:',
+                items: sessions,
+                getName: (s) => `${s.sessionId} (${s.ticketId}) - ${s.agentName} [${s.type}]`,
+                getValue: (s) => s.sessionId,
+                getCommand: (s) => `prlt session attach "${s.sessionId}" --json`,
+                jsonMode: jsonMode ? { flags, commandName: 'session attach' } : null,
+            });
+            if (!selected) {
+                return;
+            }
+            selectedSession = sessions.find(s => s.sessionId === selected);
+        }
+        if (!selectedSession) {
+            this.error('No session selected');
+        }
+        // Attach to the session
+        this.log('');
+        this.log(styles.info(`Attaching to session: ${selectedSession.sessionId}`));
+        // Default to new tab unless --current-terminal is specified
+        if (flags['current-terminal']) {
+            await this.attachInCurrentTerminal(selectedSession);
+        }
+        else {
+            await this.attachInNewTab(selectedSession, flags.terminal);
+        }
+    }
+    /**
+     * Get verified sessions from DB that have actual tmux processes
+     * DB-driven approach: Start with executions, verify tmux sessions exist
+     */
+    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 {
+            return sessions; // Not in workspace
+        }
+        try {
+            // Get active executions from DB
+            const activeExecutions = [
+                ...(executionStorage.listExecutions({ status: 'running' }) || []),
+                ...(executionStorage.listExecutions({ status: 'starting' }) || []),
+            ];
+            // Get actual tmux sessions for verification
+            const hostTmuxSessions = this.getHostTmuxSessionNames();
+            const containerTmuxSessions = this.getContainerTmuxSessionMap();
+            for (const exec of activeExecutions) {
+                if (!exec.sessionId)
+                    continue;
+                const isContainer = exec.environment === 'devcontainer';
+                let exists = false;
+                if (isContainer && exec.containerId) {
+                    const containerSessions = containerTmuxSessions.get(exec.containerId);
+                    exists = containerSessions?.includes(exec.sessionId) ?? false;
+                }
+                else {
+                    exists = hostTmuxSessions.includes(exec.sessionId);
+                }
+                // Only include sessions that actually exist
+                if (exists) {
+                    sessions.push({
+                        name: exec.sessionId,
+                        sessionId: exec.sessionId,
+                        type: isContainer ? 'container' : 'host',
+                        containerId: exec.containerId,
+                        ticketId: exec.ticketId,
+                        agentName: exec.agentName,
+                    });
+                }
+            }
+        }
+        finally {
+            db?.close();
+        }
+        return sessions;
+    }
+    /**
+     * Get list of host tmux session names
+     */
+    getHostTmuxSessionNames() {
+        try {
+            execSync('which tmux', { stdio: 'pipe' });
+            const output = execSync('tmux list-sessions -F "#{session_name}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (!output)
+                return [];
+            return output.split('\n');
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Get map of containerId -> tmux session names
+     */
+    getContainerTmuxSessionMap() {
+        const sessionMap = new Map();
+        try {
+            const containersOutput = execSync('docker ps --filter "label=devcontainer.local_folder" --format "{{.ID}}"', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+            if (!containersOutput)
+                return sessionMap;
+            for (const containerId of containersOutput.split('\n')) {
+                try {
+                    const tmuxOutput = execSync(`docker exec ${containerId} tmux list-sessions -F "#{session_name}" 2>/dev/null`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+                    if (tmuxOutput) {
+                        sessionMap.set(containerId, tmuxOutput.split('\n'));
+                    }
+                }
+                catch {
+                    // Container has no tmux sessions
+                }
+            }
+        }
+        catch {
+            // Docker not available
+        }
+        return sessionMap;
+    }
+    /**
+     * Attach to session in current terminal
+     */
+    async attachInCurrentTerminal(session) {
+        try {
+            if (session.type === 'container' && session.containerId) {
+                execSync(`docker exec -it ${session.containerId} tmux attach -t "${session.sessionId}"`, { stdio: 'inherit' });
+            }
+            else {
+                execSync(`tmux attach -t "${session.sessionId}"`, { stdio: 'inherit' });
+            }
+        }
+        catch {
+            this.error(`Failed to attach to ${session.type} session "${session.sessionId}"`);
+        }
+    }
+    /**
+     * Attach to session in a new terminal tab
+     */
+    async attachInNewTab(session, terminalApp) {
+        // Build a readable title for the tab
+        const title = `${session.ticketId} (${session.agentName})`;
+        // Create a script that sets tab title and attaches to tmux
+        const baseDir = path.join(os.homedir(), '.proletariat', 'scripts');
+        fs.mkdirSync(baseDir, { recursive: true });
+        const scriptPath = path.join(baseDir, `attach-${Date.now()}.sh`);
+        // Different attach command for container vs host sessions
+        const attachCmd = session.type === 'container' && session.containerId
+            ? `docker exec -it ${session.containerId} tmux -u attach -t "${session.sessionId}"`
+            : `tmux attach -t "${session.sessionId}"`;
+        const script = `#!/bin/bash
+# Set terminal tab title
+echo -ne "\\033]0;${title}\\007"
+echo -ne "\\033]1;${title}\\007"
+
+echo "Attaching to: ${session.sessionId} (${session.type})"
+${attachCmd}
+
+# Clean up
+rm -f "${scriptPath}"
+exec $SHELL
+`;
+        fs.writeFileSync(scriptPath, script, { mode: 0o755 });
+        // Open in new tab and run the attach script
+        try {
+            switch (terminalApp) {
+                case 'iTerm':
+                    execSync(`osascript -e '
+            tell application "iTerm"
+              activate
+              tell current window
+                set newTab to (create tab with default profile)
+                tell current session of newTab
+                  set name to "${title}"
+                  write text "${scriptPath}"
+                end tell
+              end tell
+            end tell
+          '`);
+                    break;
+                case 'Ghostty':
+                    execSync(`osascript -e '
+            tell application "Ghostty"
+              activate
+            end tell
+            tell application "System Events"
+              tell process "Ghostty"
+                keystroke "t" using command down
+                delay 0.3
+                keystroke "${scriptPath}"
+                keystroke return
+              end tell
+            end tell
+          '`);
+                    break;
+                case 'Terminal':
+                default:
+                    execSync(`osascript -e '
+            tell application "Terminal"
+              activate
+              tell application "System Events"
+                tell process "Terminal"
+                  keystroke "t" using command down
+                end tell
+              end tell
+              delay 0.3
+              do script "${scriptPath}" in front window
+            end tell
+          '`);
+                    break;
+            }
+            this.log(styles.success('Opened new tab and attaching to session'));
+        }
+        catch (error) {
+            this.error(`Failed to open terminal tab: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}