@proletariat/cli 0.1.4 → 0.3.0

package/dist/lib/agents/index.d.ts

@@ -0,0 +1,54 @@
+export interface HQConfig {
+    type: 'hq';
+    created: string;
+    workspaceName: string;
+    hasPMO: boolean;
+    agents: string[];
+    repos: string[];
+}
+/**
+ * Detect the current agent name from environment or directory structure.
+ * Returns null if not running in an agent context.
+ */
+export declare function detectAgentName(): string | null;
+/**
+ * Find the HQ root directory by looking for .proletariat/workspace.db
+ * @deprecated Use findHQRoot from '../workspace.js' instead for PRLT_HQ_PATH support
+ */
+export { findHQRoot } from '../workspace.js';
+/**
+ * Prompt user to enter agent names
+ */
+export declare function promptAgentNames(existingAgents?: string[]): Promise<string[]>;
+export interface CreateAgentOptions {
+    skipDevcontainer?: boolean;
+}
+/**
+ * Create agent worktrees (shared between HQ and workspace-only modes)
+ */
+export declare function createAgentWorktrees(workspacePath: string, agents: string[], hqPath?: string, options?: CreateAgentOptions): Promise<void>;
+/**
+ * Result from agent prompt including optional theme info
+ */
+export interface AgentPromptResult {
+    agents: string[];
+    themeId?: string;
+    customTheme?: {
+        name: string;
+        displayName: string;
+        names: string[];
+    };
+}
+/**
+ * Prompt user for agent selection with theme options
+ */
+export declare function promptForAgents(): Promise<string[]>;
+/**
+ * Prompt user for agent selection with theme options (returns full result)
+ * Simplified flow: pick theme -> auto-create 5 random agents
+ */
+export declare function promptForAgentsWithTheme(): Promise<AgentPromptResult>;
+/**
+ * Add agents to HQ (used by both init and agent add commands)
+ */
+export declare function addAgentsToHQ(hqPath: string, agents: string[]): Promise<void>;

package/dist/lib/agents/index.js

@@ -0,0 +1,382 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { isValidAgentName, getSuggestedAgentNames, BUILTIN_THEMES, getThemePersistentDir } from '../themes.js';
+import { getWorkspaceRepositories, getActiveTheme } from '../database/index.js';
+import { styles } from '../styles.js';
+import { createDevcontainerConfig } from '../execution/devcontainer.js';
+/**
+ * Detect the current agent name from environment or directory structure.
+ * Returns null if not running in an agent context.
+ */
+export function detectAgentName() {
+    // Check environment variable first (set in devcontainer)
+    if (process.env.PRLT_AGENT_NAME) {
+        return process.env.PRLT_AGENT_NAME;
+    }
+    // Try to detect from directory structure
+    const cwd = process.cwd();
+    // Devcontainer pattern: /workspace/proletariat-{agent}
+    const workspaceMatch = cwd.match(/\/workspace\/[^/]+-(\w+)/);
+    if (workspaceMatch) {
+        return workspaceMatch[1];
+    }
+    // Host pattern: agents/staff/{agent}
+    const staffMatch = cwd.match(/agents\/staff\/(\w+)/);
+    if (staffMatch) {
+        return staffMatch[1];
+    }
+    // Try git branch pattern: agent-{name}
+    try {
+        const branch = execSync('git branch --show-current', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const agentBranchMatch = branch.match(/^agent-(\w+)$/);
+        if (agentBranchMatch) {
+            return agentBranchMatch[1];
+        }
+    }
+    catch {
+        // Ignore git errors
+    }
+    return null;
+}
+/**
+ * Find the HQ root directory by looking for .proletariat/workspace.db
+ * @deprecated Use findHQRoot from '../workspace.js' instead for PRLT_HQ_PATH support
+ */
+export { findHQRoot } from '../workspace.js';
+/**
+ * Prompt user to enter agent names
+ */
+export async function promptAgentNames(existingAgents = []) {
+    const suggestions = getSuggestedAgentNames().filter(n => !existingAgents.includes(n));
+    const { agentNames } = await inquirer.prompt([{
+            type: 'input',
+            name: 'agentNames',
+            message: `Enter agent names (space-separated, e.g., "${suggestions.slice(0, 2).join(' ')}"):`,
+            validate: (input) => {
+                if (!input.trim()) {
+                    return 'Please enter at least one agent name';
+                }
+                const names = input.trim().split(/\s+/);
+                const invalid = names.filter(n => !isValidAgentName(n));
+                if (invalid.length > 0) {
+                    return `Invalid agent names: ${invalid.join(', ')}. Names must be lowercase alphanumeric with optional hyphens/underscores.`;
+                }
+                const duplicates = names.filter(n => existingAgents.includes(n));
+                if (duplicates.length > 0) {
+                    return `These agents already exist: ${duplicates.join(', ')}`;
+                }
+                return true;
+            },
+        }]);
+    return agentNames.trim().split(/\s+/).filter(Boolean);
+}
+/**
+ * Create agent worktrees (shared between HQ and workspace-only modes)
+ */
+export async function createAgentWorktrees(workspacePath, agents, hqPath, options) {
+    if (hqPath) {
+        // HQ mode - create worktrees for all repos in repos/ directory
+        const reposDir = path.join(hqPath, 'repos');
+        // Get repositories from database instead of JSON config
+        const repos = getWorkspaceRepositories(hqPath);
+        if (repos.length > 0) {
+            // Create worktrees for each agent across all repositories
+            for (const agent of agents) {
+                const agentDir = path.join(workspacePath, agent);
+                console.log(chalk.blue(`Creating agent: ${agent}...`));
+                try {
+                    // Create agent directory
+                    fs.mkdirSync(agentDir, { recursive: true });
+                    // Track which repos successfully had worktrees created
+                    const createdWorktrees = [];
+                    // Create worktrees for all repositories
+                    for (const repo of repos) {
+                        const sourceRepo = path.join(reposDir, repo.name);
+                        // Worktree directory is just the repo name (the agent name is already in the parent path)
+                        const worktreeDir = path.join(agentDir, repo.name);
+                        if (fs.existsSync(sourceRepo)) {
+                            // Check if repo is empty (no commits)
+                            let isEmptyRepo = false;
+                            try {
+                                execSync('git rev-parse HEAD', { cwd: sourceRepo, stdio: 'pipe' });
+                            }
+                            catch {
+                                isEmptyRepo = true;
+                            }
+                            if (isEmptyRepo) {
+                                console.log(chalk.yellow(`  Skipping ${repo.name} (empty repository with no commits)`));
+                                continue;
+                            }
+                            console.log(styles.muted(`  Creating worktree for ${repo.name}...`));
+                            // Fetch latest from origin to ensure we have up-to-date main
+                            try {
+                                execSync(`git fetch origin main`, {
+                                    cwd: sourceRepo,
+                                    stdio: 'pipe'
+                                });
+                            }
+                            catch {
+                                // Ignore fetch errors (might be offline)
+                                console.log(chalk.yellow(`  Warning: Could not fetch origin/main, using local state`));
+                            }
+                            // Determine the base ref to use (origin/main, main, or HEAD)
+                            let baseRef = 'origin/main';
+                            try {
+                                execSync(`git rev-parse ${baseRef}`, { cwd: sourceRepo, stdio: 'pipe' });
+                            }
+                            catch {
+                                // origin/main doesn't exist, try local main
+                                try {
+                                    execSync('git rev-parse main', { cwd: sourceRepo, stdio: 'pipe' });
+                                    baseRef = 'main';
+                                }
+                                catch {
+                                    // No main branch, use HEAD
+                                    baseRef = 'HEAD';
+                                }
+                            }
+                            // Create git worktree for the agent
+                            const branchName = `agent-${agent}`;
+                            try {
+                                execSync(`git worktree add "${worktreeDir}" -b ${branchName} ${baseRef}`, {
+                                    cwd: sourceRepo,
+                                    stdio: 'inherit'
+                                });
+                                createdWorktrees.push(repo.name);
+                            }
+                            catch {
+                                // Branch might already exist, try to use it or clean up
+                                console.log(chalk.yellow(`  Branch ${branchName} already exists, attempting to reuse or clean up...`));
+                                try {
+                                    // Try without creating a new branch (use existing)
+                                    execSync(`git worktree add "${worktreeDir}" ${branchName}`, {
+                                        cwd: sourceRepo,
+                                        stdio: 'inherit'
+                                    });
+                                    createdWorktrees.push(repo.name);
+                                }
+                                catch {
+                                    // If that fails too, clean up the orphaned branch and try again
+                                    try {
+                                        execSync(`git branch -D ${branchName}`, {
+                                            cwd: sourceRepo,
+                                            stdio: 'pipe'
+                                        });
+                                        execSync(`git worktree add "${worktreeDir}" -b ${branchName} ${baseRef}`, {
+                                            cwd: sourceRepo,
+                                            stdio: 'inherit'
+                                        });
+                                        createdWorktrees.push(repo.name);
+                                    }
+                                    catch (finalError) {
+                                        throw new Error(`Failed to create worktree after cleanup: ${finalError}`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Create devcontainer config for sandboxed execution (only for repos with worktrees)
+                    // Note: Agent metadata is stored in SQLite (agents table), not in config files
+                    if (!options?.skipDevcontainer && createdWorktrees.length > 0) {
+                        console.log(styles.muted(`  Creating devcontainer config...`));
+                        createDevcontainerConfig({
+                            agentName: agent,
+                            agentDir,
+                            repoWorktrees: createdWorktrees,
+                        });
+                    }
+                    console.log(chalk.green(`✅ Agent ${agent} created with ${createdWorktrees.length} worktree(s)`));
+                }
+                catch (error) {
+                    console.log(chalk.red(`Failed to create agent ${agent}: ${error}`));
+                }
+            }
+        }
+        else {
+            console.log(chalk.yellow('No repositories found in HQ. Creating placeholder agent directories.'));
+            // Create placeholder directories for now
+            for (const agent of agents) {
+                const agentDir = path.join(workspacePath, agent);
+                fs.mkdirSync(agentDir, { recursive: true });
+                console.log(chalk.green(`✅ Placeholder agent ${agent} created`));
+            }
+        }
+    }
+    else {
+        // Workspace-only mode - use current repo
+        const sourceRepo = process.cwd();
+        const repoName = path.basename(sourceRepo);
+        for (const agent of agents) {
+            const agentDir = path.join(workspacePath, agent);
+            // Worktree directory is just the repo name (the agent name is already in the parent path)
+            const worktreeDir = path.join(agentDir, repoName);
+            console.log(chalk.blue(`Creating agent: ${agent}...`));
+            try {
+                // Check if repo is empty (no commits)
+                let isEmptyRepo = false;
+                try {
+                    execSync('git rev-parse HEAD', { cwd: sourceRepo, stdio: 'pipe' });
+                }
+                catch {
+                    isEmptyRepo = true;
+                }
+                if (isEmptyRepo) {
+                    console.log(chalk.yellow(`  Skipping (empty repository with no commits)`));
+                    continue;
+                }
+                // Create agent directory
+                fs.mkdirSync(agentDir, { recursive: true });
+                // Fetch latest from origin to ensure we have up-to-date main
+                try {
+                    execSync(`git fetch origin main`, {
+                        cwd: sourceRepo,
+                        stdio: 'pipe'
+                    });
+                }
+                catch {
+                    // Ignore fetch errors (might be offline)
+                    console.log(chalk.yellow(`  Warning: Could not fetch origin/main, using local state`));
+                }
+                // Determine the base ref to use (origin/main, main, or HEAD)
+                let baseRef = 'origin/main';
+                try {
+                    execSync(`git rev-parse ${baseRef}`, { cwd: sourceRepo, stdio: 'pipe' });
+                }
+                catch {
+                    // origin/main doesn't exist, try local main
+                    try {
+                        execSync('git rev-parse main', { cwd: sourceRepo, stdio: 'pipe' });
+                        baseRef = 'main';
+                    }
+                    catch {
+                        // No main branch, use HEAD
+                        baseRef = 'HEAD';
+                    }
+                }
+                // Create git worktree for the agent
+                const branchName = `agent-${agent}`;
+                try {
+                    execSync(`git worktree add "${worktreeDir}" -b ${branchName} ${baseRef}`, {
+                        cwd: sourceRepo,
+                        stdio: 'inherit'
+                    });
+                }
+                catch {
+                    // Branch might already exist, try to use it or clean up
+                    console.log(chalk.yellow(`  Branch ${branchName} already exists, attempting to reuse or clean up...`));
+                    try {
+                        // Try without creating a new branch (use existing)
+                        execSync(`git worktree add "${worktreeDir}" ${branchName}`, {
+                            cwd: sourceRepo,
+                            stdio: 'inherit'
+                        });
+                    }
+                    catch {
+                        // If that fails too, clean up the orphaned branch and try again
+                        try {
+                            execSync(`git branch -D ${branchName}`, {
+                                cwd: sourceRepo,
+                                stdio: 'pipe'
+                            });
+                            execSync(`git worktree add "${worktreeDir}" -b ${branchName} ${baseRef}`, {
+                                cwd: sourceRepo,
+                                stdio: 'inherit'
+                            });
+                        }
+                        catch (finalError) {
+                            throw new Error(`Failed to create worktree after cleanup: ${finalError}`);
+                        }
+                    }
+                }
+                // Create devcontainer config for sandboxed execution
+                // Note: Agent metadata is stored in SQLite (agents table), not in config files
+                if (!options?.skipDevcontainer) {
+                    console.log(styles.muted(`  Creating devcontainer config...`));
+                    createDevcontainerConfig({
+                        agentName: agent,
+                        agentDir,
+                        repoWorktrees: [repoName],
+                    });
+                }
+                console.log(chalk.green(`✅ Agent ${agent} created with worktree`));
+            }
+            catch (error) {
+                console.log(chalk.red(`Failed to create agent ${agent}: ${error}`));
+            }
+        }
+    }
+}
+/**
+ * Prompt user for agent selection with theme options
+ */
+export async function promptForAgents() {
+    const result = await promptForAgentsWithTheme();
+    return result.agents;
+}
+/**
+ * Prompt user for agent selection with theme options (returns full result)
+ * Simplified flow: pick theme -> auto-create 5 random agents
+ */
+export async function promptForAgentsWithTheme() {
+    // Build theme choices with preview of names
+    const themeChoices = BUILTIN_THEMES.map(t => ({
+        name: `${t.displayName} (${t.names.slice(0, 4).join(', ')}...)`,
+        value: t.id
+    }));
+    const { selectedTheme } = await inquirer.prompt([{
+            type: 'list',
+            name: 'selectedTheme',
+            message: 'Agent naming theme:',
+            choices: [
+                ...themeChoices,
+                new inquirer.Separator(),
+                { name: 'Skip (add agents later)', value: 'skip' }
+            ]
+        }]);
+    if (selectedTheme === 'skip') {
+        return { agents: [] };
+    }
+    // Get the theme
+    const theme = BUILTIN_THEMES.find(t => t.id === selectedTheme);
+    if (!theme) {
+        return { agents: [] };
+    }
+    // Randomly select 10 agents from the theme
+    const shuffled = [...theme.names].sort(() => Math.random() - 0.5);
+    const selected = shuffled.slice(0, 10);
+    console.log(chalk.blue(`\nCreating 10 staff agents: ${selected.join(', ')}`));
+    return { agents: selected, themeId: selectedTheme };
+}
+/**
+ * Add agents to HQ (used by both init and agent add commands)
+ */
+export async function addAgentsToHQ(hqPath, agents) {
+    // Import database functions for getting/adding agents
+    const { getWorkspaceAgents, addAgentsToDatabase } = await import('../database/index.js');
+    // Get existing agents from database
+    const existingAgents = getWorkspaceAgents(hqPath);
+    const existingAgentNames = new Set(existingAgents.map(a => a.name));
+    // Filter out already existing agents
+    const newAgents = agents.filter(name => {
+        if (existingAgentNames.has(name)) {
+            console.log(chalk.yellow(`Agent ${name} already exists`));
+            return false;
+        }
+        return true;
+    });
+    if (newAgents.length === 0) {
+        console.log(chalk.yellow('No new agents to add.'));
+        return;
+    }
+    // Create worktrees (use theme-specific directory)
+    const activeTheme = getActiveTheme(hqPath);
+    const persistentDir = getThemePersistentDir(activeTheme?.id);
+    const workspacePath = path.join(hqPath, 'agents', persistentDir);
+    await createAgentWorktrees(workspacePath, newAgents, hqPath);
+    // Add agents to database
+    addAgentsToDatabase(hqPath, newAgents);
+    console.log(chalk.green(`\n🎉 Added ${newAgents.length} agent(s) successfully!`));
+}

package/dist/lib/branch/index.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Branch Utilities
+ *
+ * Utilities for creating and validating conventional branch names.
+ * Format: {type}/{coder}/{description} or {type}/{description}
+ */
+export declare const BRANCH_TYPES: {
+    readonly feat: "New feature";
+    readonly fix: "Bug fix";
+    readonly rfct: "Refactoring (no functional change)";
+    readonly docs: "Documentation only";
+    readonly test: "Test additions or corrections";
+    readonly chore: "Maintenance tasks, no production code";
+    readonly perf: "Performance improvement";
+    readonly ci: "CI/CD configuration changes";
+    readonly build: "Build system or external dependency changes";
+    readonly sec: "Security fixes or improvements";
+    readonly db: "Database migrations or schema changes";
+    readonly rel: "Release preparation";
+    readonly ship: "Shipping, deployment, and launch";
+    readonly grow: "Growth and marketing initiatives";
+    readonly cx: "Customer experience and support";
+    readonly strat: "Strategy and planning";
+    readonly ops: "Business operations";
+};
+export type BranchType = keyof typeof BRANCH_TYPES;
+export declare const CONVENTIONAL_TYPES: BranchType[];
+export declare const EXTENDED_TYPES: BranchType[];
+export declare const FOUNDER_TYPES: BranchType[];
+export declare const DEVELOPMENT_TYPES: BranchType[];
+export declare const BUSINESS_TYPES: BranchType[];
+export declare function isKebabCase(str: string): boolean;
+export declare function isValidBranchType(type: string): type is BranchType;
+export interface BranchParts {
+    ticketId?: string;
+    type: BranchType;
+    owner?: string;
+    agent?: string;
+    description: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    parts?: BranchParts;
+    error?: string;
+}
+/**
+ * Check if a string looks like a ticket ID.
+ */
+export declare function isTicketId(str: string): boolean;
+/**
+ * Parse and validate a branch name against conventional format.
+ *
+ * Supported formats:
+ * - {ticketId}/{type}/{owner}/{agent}/{description} - full format with ticket
+ * - {ticketId}/{type}/{owner}/{description} - ticket format without agent (manual)
+ * - {type}/{owner}/{description} - legacy format without ticket
+ * - {type}/{description} - minimal format
+ */
+export declare function validateBranchName(name: string): ValidationResult;
+/**
+ * Build a branch name from parts.
+ *
+ * Formats:
+ * - With ticket + agent: {ticketId}/{type}/{owner}/{agent}/{description}
+ * - With ticket (manual): {ticketId}/{type}/{owner}/{description}
+ * - Without ticket: {type}/{owner}/{description}
+ * - Minimal: {type}/{description}
+ */
+export declare function buildBranchName(type: BranchType, description: string, options?: {
+    ticketId?: string;
+    owner?: string;
+    agent?: string;
+}): string;
+/**
+ * Convert a string to kebab-case.
+ */
+export declare function toKebabCase(str: string): string;
+export interface BranchInfo {
+    name: string;
+    current: boolean;
+    ticketId?: string;
+    type?: BranchType;
+    owner?: string;
+    agent?: string;
+    description?: string;
+    tracking?: string;
+}
+/**
+ * Get current branch name.
+ */
+export declare function getCurrentBranch(cwd?: string): string | null;
+/**
+ * List all branches with parsed info.
+ */
+export declare function listBranches(cwd?: string, includeRemote?: boolean): BranchInfo[];
+/**
+ * Check if a branch exists.
+ */
+export declare function branchExists(name: string, cwd?: string): boolean;
+/**
+ * Create a new branch.
+ * @param startPoint - Optional starting point (e.g., 'origin/main')
+ */
+export declare function createBranch(name: string, cwd?: string, checkout?: boolean, startPoint?: string): void;
+/**
+ * Fetch from origin.
+ */
+export declare function fetchOrigin(ref?: string, cwd?: string): boolean;
+/**
+ * Switch to an existing branch.
+ */
+export declare function checkoutBranch(name: string, cwd?: string): void;
+/**
+ * Create an empty commit.
+ */
+export declare function createEmptyCommit(message: string, cwd?: string): void;
+/**
+ * Check if in a git repository.
+ */
+export declare function isGitRepo(cwd?: string): boolean;