@proletariat/cli 0.3.20 → 0.3.22

package/dist/commands/workspace/prune.js

@@ -0,0 +1,186 @@
+import { Command, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { styles } from '../../lib/styles.js';
+import { getRegisteredHeadquarters, unregisterHeadquarters, } from '../../lib/machine-config.js';
+import { getWorkspaceAgents, removeAgentsFromDatabase, getDatabasePath, } from '../../lib/database/index.js';
+export default class WorkspacePrune extends Command {
+    static description = 'Remove stale workspace entries and agents with deleted worktrees';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --dry-run',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        'dry-run': Flags.boolean({
+            char: 'd',
+            description: 'Show what would be removed without removing',
+            default: false,
+        }),
+        json: Flags.boolean({
+            description: 'Output as JSON',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(WorkspacePrune);
+        // Find stale entries
+        const staleWorkspaces = this.findStaleWorkspaces();
+        const staleAgents = this.findStaleAgents();
+        const totalStale = staleWorkspaces.length + staleAgents.length;
+        // JSON output
+        if (flags.json) {
+            const output = {
+                dryRun: flags['dry-run'],
+                staleWorkspaces: staleWorkspaces.map(w => ({
+                    name: w.name,
+                    path: w.path,
+                })),
+                staleAgents: staleAgents.map(a => ({
+                    workspaceName: a.workspaceName,
+                    agentName: a.agentName,
+                    expectedPath: a.expectedPath,
+                })),
+                totalRemoved: flags['dry-run'] ? 0 : totalStale,
+                totalFound: totalStale,
+            };
+            this.log(JSON.stringify(output, null, 2));
+            if (!flags['dry-run'] && totalStale > 0) {
+                this.performPrune(staleWorkspaces, staleAgents);
+            }
+            return;
+        }
+        // Human-readable output
+        this.log(`\n${styles.header('Workspace Prune')}`);
+        this.log('─'.repeat(50));
+        if (totalStale === 0) {
+            this.log(styles.success('\nNo stale entries found.'));
+            return;
+        }
+        // Show stale workspaces
+        if (staleWorkspaces.length > 0) {
+            this.log(styles.subheader('\nStale workspace registrations:'));
+            for (const workspace of staleWorkspaces) {
+                this.log(`  ${styles.removed('×')} ${styles.emphasis(workspace.name)}`);
+                this.log(styles.muted(`    Path no longer exists: ${workspace.path}`));
+            }
+        }
+        // Show stale agents
+        if (staleAgents.length > 0) {
+            this.log(styles.subheader('\nAgents with deleted worktrees:'));
+            // Group by workspace for cleaner output
+            const agentsByWorkspace = new Map();
+            for (const agent of staleAgents) {
+                const list = agentsByWorkspace.get(agent.workspaceName) || [];
+                list.push(agent);
+                agentsByWorkspace.set(agent.workspaceName, list);
+            }
+            for (const [workspaceName, agents] of agentsByWorkspace) {
+                this.log(`  ${styles.muted(`In ${workspaceName}:`)}`);
+                for (const agent of agents) {
+                    this.log(`    ${styles.removed('×')} ${agent.agentName}`);
+                    this.log(styles.muted(`      Expected: ${agent.expectedPath}`));
+                }
+            }
+        }
+        // Summary
+        this.log('');
+        if (flags['dry-run']) {
+            this.log(styles.warning(`[DRY RUN] Would remove:`));
+            if (staleWorkspaces.length > 0) {
+                this.log(styles.muted(`  • ${staleWorkspaces.length} workspace registration(s)`));
+            }
+            if (staleAgents.length > 0) {
+                this.log(styles.muted(`  • ${staleAgents.length} agent record(s)`));
+            }
+            this.log('');
+            this.log(styles.muted('Run without --dry-run to remove these entries.'));
+        }
+        else {
+            // Perform the actual prune
+            this.performPrune(staleWorkspaces, staleAgents);
+            this.log(styles.success('Pruned:'));
+            if (staleWorkspaces.length > 0) {
+                this.log(styles.muted(`  • ${staleWorkspaces.length} workspace registration(s)`));
+            }
+            if (staleAgents.length > 0) {
+                this.log(styles.muted(`  • ${staleAgents.length} agent record(s)`));
+            }
+        }
+        this.log('');
+    }
+    findStaleWorkspaces() {
+        const workspaces = getRegisteredHeadquarters();
+        const stale = [];
+        for (const workspace of workspaces) {
+            if (!fs.existsSync(workspace.path)) {
+                stale.push({
+                    name: workspace.name,
+                    path: workspace.path,
+                });
+            }
+        }
+        return stale;
+    }
+    findStaleAgents() {
+        const workspaces = getRegisteredHeadquarters();
+        const stale = [];
+        for (const workspace of workspaces) {
+            // Skip workspaces that don't exist (handled separately)
+            if (!fs.existsSync(workspace.path)) {
+                continue;
+            }
+            // Skip workspaces without a database
+            const dbPath = getDatabasePath(workspace.path);
+            if (!fs.existsSync(dbPath)) {
+                continue;
+            }
+            try {
+                // Get active agents in this workspace
+                const agents = getWorkspaceAgents(workspace.path, false);
+                for (const agent of agents) {
+                    // Determine expected directory path
+                    let agentDir;
+                    if (agent.worktree_path) {
+                        agentDir = path.join(workspace.path, agent.worktree_path);
+                    }
+                    else if (agent.type === 'ephemeral') {
+                        agentDir = path.join(workspace.path, 'agents', 'temp', agent.name);
+                    }
+                    else {
+                        agentDir = path.join(workspace.path, 'agents', 'staff', agent.name);
+                    }
+                    // If directory doesn't exist, mark as stale
+                    if (!fs.existsSync(agentDir)) {
+                        stale.push({
+                            workspacePath: workspace.path,
+                            workspaceName: workspace.name,
+                            agentName: agent.name,
+                            expectedPath: agentDir,
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip workspaces where we can't read agents (e.g., database issues)
+                continue;
+            }
+        }
+        return stale;
+    }
+    performPrune(staleWorkspaces, staleAgents) {
+        // Remove stale workspace registrations
+        for (const workspace of staleWorkspaces) {
+            unregisterHeadquarters(workspace.path);
+        }
+        // Remove stale agents, grouped by workspace
+        const agentsByWorkspace = new Map();
+        for (const agent of staleAgents) {
+            const list = agentsByWorkspace.get(agent.workspacePath) || [];
+            list.push(agent.agentName);
+            agentsByWorkspace.set(agent.workspacePath, list);
+        }
+        for (const [workspacePath, agentNames] of agentsByWorkspace) {
+            removeAgentsFromDatabase(workspacePath, agentNames);
+        }
+    }
+}

package/dist/commands/workspace/remove.js

@@ -17,6 +17,8 @@ export default class WorkspaceRemove extends PromptCommand {
     };
     static flags = {
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

package/dist/commands/workspace/use.js

@@ -18,6 +18,8 @@ export default class WorkspaceUse extends PromptCommand {
     };
     static flags = {
         json: Flags.boolean({
+            char: 'm',
+            aliases: ['machine'],
             description: 'Output prompt configuration as JSON (for AI agents/scripts)',
             default: false,
         }),

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

@@ -1,4 +1,11 @@
 import { Agent, Repository, MountMode as DBMountMode } from '../database/index.js';
+/**
+ * Format a list of agents for display in error messages.
+ * Truncates long lists to avoid overwhelming output.
+ */
+export declare function formatAgentList(agents: {
+    name: string;
+}[], maxShow?: number): string;
 export interface AgentStatus {
     name: string;
     exists: boolean;

package/dist/lib/agents/commands.js

@@ -9,6 +9,17 @@ import { getWorkspaceConfig, getWorkspaceAgents, getWorkspaceRepositories, getAg
 import { isValidAgentName, getSuggestedAgentNames, generateEphemeralAgentName, getThemePersistentDir, getThemeEphemeralDir, extractBaseName, getAgentBaseName, } from '../themes.js';
 import { createDevcontainerConfig } from '../execution/devcontainer.js';
 import { getPMOContext } from '../pmo/index.js';
+/**
+ * Format a list of agents for display in error messages.
+ * Truncates long lists to avoid overwhelming output.
+ */
+export function formatAgentList(agents, maxShow = 10) {
+    const names = agents.map(a => a.name);
+    if (names.length <= maxShow) {
+        return names.join(', ');
+    }
+    return `${names.slice(0, maxShow).join(', ')} ...and ${names.length - maxShow} more. Run 'prlt agent list' to see all.`;
+}
 /**
  * Find workspace root and return workspace information.
  *

package/dist/lib/execution/runners.js

@@ -612,8 +612,7 @@ export function isDockerRunning() {
             execSync('docker info', { stdio: 'pipe', timeout });
             return true;
         }
-        catch (err) {
-            console.debug(`[runners:docker] Docker check attempt ${attempt}/${maxRetries} failed:`, err);
+        catch {
             if (attempt === maxRetries) {
                 return false;
             }

package/dist/lib/pmo/base-command.d.ts

@@ -2,7 +2,7 @@ import { type PMOContext } from './pmo-context.js';
 import { PromptCommand } from '../prompt-command.js';
 import { type JsonFlags } from '../prompt-json.js';
 /**
- * Base flags for JSON/agent mode support (legacy)
+ * Base flags for JSON/agent mode support
  * Include these in your command's flags by spreading: ...jsonModeFlags
  * @deprecated Use machineOutputFlags instead
  */
@@ -12,10 +12,9 @@ export declare const jsonModeFlags: {
 /**
  * Base flags for machine-readable output mode
  * Include these in your command's flags by spreading: ...machineOutputFlags
- * Supports both --machine (new) and --json (legacy, deprecated)
+ * --json is the primary flag, -m/--machine are aliases
  */
 export declare const machineOutputFlags: {
-    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
 /**
@@ -23,7 +22,6 @@ export declare const machineOutputFlags: {
  * Include these in your command's flags by spreading: ...pmoBaseFlags
  */
 export declare const pmoBaseFlags: {
-    machine: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
 };

package/dist/lib/pmo/base-command.js

@@ -5,31 +5,29 @@ import { styles } from '../styles.js';
 import { PromptCommand } from '../prompt-command.js';
 import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, } from '../prompt-json.js';
 /**
- * Base flags for JSON/agent mode support (legacy)
+ * Base flags for JSON/agent mode support
  * Include these in your command's flags by spreading: ...jsonModeFlags
  * @deprecated Use machineOutputFlags instead
  */
 export const jsonModeFlags = {
     json: Flags.boolean({
-        description: 'Output prompts as JSON for AI agents/scripts',
+        char: 'm',
+        aliases: ['machine'],
+        description: 'Output as JSON for AI agents/scripts',
         default: false,
     }),
 };
 /**
  * Base flags for machine-readable output mode
  * Include these in your command's flags by spreading: ...machineOutputFlags
- * Supports both --machine (new) and --json (legacy, deprecated)
+ * --json is the primary flag, -m/--machine are aliases
  */
 export const machineOutputFlags = {
-    machine: Flags.boolean({
-        char: 'm',
-        description: 'Output as JSON for AI agents/scripts (machine-readable mode)',
-        default: false,
-    }),
     json: Flags.boolean({
-        description: 'Output as JSON (deprecated, use --machine)',
+        char: 'm',
+        aliases: ['machine'],
+        description: 'Output as JSON for AI agents/scripts',
         default: false,
-        hidden: true, // Hide from help since it's deprecated
     }),
 };
 /**

package/dist/lib/pmo/schema.d.ts

@@ -8,6 +8,7 @@ export declare const PMO_TABLES: {
     readonly projects: "pmo_projects";
     readonly initiatives: "pmo_initiatives";
     readonly tickets: "pmo_tickets";
+    readonly categories: "pmo_categories";
     readonly board_views: "pmo_board_views";
     readonly subtasks: "pmo_subtasks";
     readonly ticket_metadata: "pmo_ticket_metadata";
@@ -41,6 +42,7 @@ export declare const PMO_TABLES: {
 export declare const PMO_TABLE_SCHEMAS: {
     readonly projects: "\n    CREATE TABLE IF NOT EXISTS pmo_projects (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      template TEXT,\n      description TEXT,\n      status TEXT NOT NULL DEFAULT 'active',\n      phase_id TEXT,\n      workflow_id TEXT,\n      is_archived INTEGER NOT NULL DEFAULT 0,\n      target_date TIMESTAMP,\n      initiative_id TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (phase_id) REFERENCES pmo_phases(id) ON DELETE SET NULL,\n      FOREIGN KEY (workflow_id) REFERENCES pmo_workflows(id) ON DELETE SET NULL\n    )";
     readonly initiatives: "\n    CREATE TABLE IF NOT EXISTS pmo_initiatives (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      objective TEXT,\n      key_results TEXT,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
+    readonly categories: "\n    CREATE TABLE IF NOT EXISTS pmo_categories (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL,\n      type TEXT NOT NULL CHECK (type IN ('ticket', 'status')),\n      description TEXT,\n      color TEXT,\n      position INTEGER NOT NULL DEFAULT 0,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      UNIQUE(name, type)\n    )";
     readonly workflows: "\n    CREATE TABLE IF NOT EXISTS pmo_workflows (\n      id TEXT PRIMARY KEY,\n      name TEXT NOT NULL UNIQUE,\n      description TEXT,\n      is_builtin INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n    )";
     readonly workflow_statuses: "\n    CREATE TABLE IF NOT EXISTS pmo_workflow_statuses (\n      id TEXT PRIMARY KEY,\n      workflow_id TEXT NOT NULL,\n      name TEXT NOT NULL,\n      category TEXT NOT NULL,\n      position INTEGER NOT NULL DEFAULT 0,\n      color TEXT,\n      description TEXT,\n      is_default INTEGER NOT NULL DEFAULT 0,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      FOREIGN KEY (workflow_id) REFERENCES pmo_workflows(id) ON DELETE CASCADE,\n      UNIQUE(workflow_id, name)\n    )";
     readonly columns: "\n    CREATE TABLE IF NOT EXISTS pmo_columns (\n      id TEXT NOT NULL,\n      project_id TEXT NOT NULL DEFAULT 'default',\n      name TEXT NOT NULL,\n      position INTEGER NOT NULL,\n      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,\n      PRIMARY KEY (project_id, id)\n    )";

package/dist/lib/pmo/schema.js

@@ -11,6 +11,7 @@ export const PMO_TABLES = {
     projects: 'pmo_projects',
     initiatives: 'pmo_initiatives',
     tickets: 'pmo_tickets',
+    categories: 'pmo_categories',
     board_views: 'pmo_board_views', // Saved board view configurations
     subtasks: 'pmo_subtasks',
     ticket_metadata: 'pmo_ticket_metadata',
@@ -75,6 +76,19 @@ export const PMO_TABLE_SCHEMAS = {
       created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
       updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
     )`,
+    // Categories for tickets and status types
+    categories: `
+    CREATE TABLE IF NOT EXISTS ${PMO_TABLES.categories} (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL CHECK (type IN ('ticket', 'status')),
+      description TEXT,
+      color TEXT,
+      position INTEGER NOT NULL DEFAULT 0,
+      is_builtin INTEGER NOT NULL DEFAULT 0,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      UNIQUE(name, type)
+    )`,
     // Shared workflow definitions - projects reference these via workflow_id
     workflows: `
     CREATE TABLE IF NOT EXISTS ${PMO_TABLES.workflows} (
@@ -484,6 +498,8 @@ export const PMO_INDEXES = `
   CREATE INDEX IF NOT EXISTS idx_pmo_roadmap_projects_roadmap ON ${PMO_TABLES.roadmap_projects}(roadmap_id);
   CREATE INDEX IF NOT EXISTS idx_pmo_roadmap_projects_project ON ${PMO_TABLES.roadmap_projects}(project_id);
   CREATE INDEX IF NOT EXISTS idx_pmo_roadmap_projects_position ON ${PMO_TABLES.roadmap_projects}(roadmap_id, position);
+  CREATE INDEX IF NOT EXISTS idx_pmo_categories_type ON ${PMO_TABLES.categories}(type);
+  CREATE INDEX IF NOT EXISTS idx_pmo_categories_position ON ${PMO_TABLES.categories}(type, position);
 `;
 // =============================================================================
 // Combined Schema
@@ -499,6 +515,7 @@ export const PMO_SCHEMA_SQL = [
     PMO_TABLE_SCHEMAS.workflow_statuses, // Workflow statuses (= board columns)
     PMO_TABLE_SCHEMAS.projects,
     PMO_TABLE_SCHEMAS.initiatives,
+    PMO_TABLE_SCHEMAS.categories, // Ticket and status categories
     // PMO_TABLE_SCHEMAS.templates,  // REMOVED: workflows are now used directly
     PMO_TABLE_SCHEMAS.specs, // Must be before tickets (FK reference)
     PMO_TABLE_SCHEMAS.spec_dependencies, // Spec-to-spec dependencies

package/dist/lib/pmo/storage/base.d.ts

@@ -33,6 +33,10 @@ export declare function seedBuiltinActions(db: Database.Database): void;
  * Seed built-in ticket templates.
  */
 export declare function seedBuiltinTicketTemplates(db: Database.Database): void;
+/**
+ * Seed built-in categories from TICKET_CATEGORIES and STATE_CATEGORY_ORDER.
+ */
+export declare function seedBuiltinCategories(db: Database.Database): void;
 /**
  * Update board timestamp for a project.
  */

package/dist/lib/pmo/storage/base.js

@@ -3,6 +3,7 @@
  * This module handles database setup and provides shared utilities.
  */
 import { PMO_TABLES, PMO_SCHEMA_SQL, validateTicketSchema } from '../schema.js';
+import { TICKET_CATEGORIES, STATE_CATEGORY_ORDER } from '../types.js';
 import { BUILTIN_TEMPLATES } from '../templates-builtin.js';
 const T = PMO_TABLES;
 /**
@@ -802,6 +803,36 @@ Why is this refactor needed?
         insertTemplate.run(template.id, template.name, template.description || null, template.titlePattern || null, template.descriptionTemplate || null, template.defaultPriority || null, template.defaultCategory || null, null, null, null, '[]', JSON.stringify(template.suggestedSubtasks || []), now);
     }
 }
+/**
+ * Seed built-in categories from TICKET_CATEGORIES and STATE_CATEGORY_ORDER.
+ */
+export function seedBuiltinCategories(db) {
+    const insertCategory = db.prepare(`
+    INSERT OR IGNORE INTO ${T.categories} (id, name, type, description, position, is_builtin, created_at)
+    VALUES (?, ?, ?, ?, ?, 1, ?)
+  `);
+    const now = new Date().toISOString();
+    // Seed ticket categories from TICKET_CATEGORIES
+    for (let i = 0; i < TICKET_CATEGORIES.length; i++) {
+        const category = TICKET_CATEGORIES[i];
+        const id = `ticket-${category}`;
+        insertCategory.run(id, category, 'ticket', null, i, now);
+    }
+    // Seed status categories from STATE_CATEGORY_ORDER
+    const statusCategoryDescriptions = {
+        triage: 'Inbox - needs review before entering workflow',
+        backlog: 'Not yet scheduled for work',
+        unstarted: 'Scheduled but work has not begun',
+        started: 'Work is actively in progress',
+        completed: 'Work finished successfully',
+        canceled: 'Work will not be done',
+    };
+    for (let i = 0; i < STATE_CATEGORY_ORDER.length; i++) {
+        const category = STATE_CATEGORY_ORDER[i];
+        const id = `status-${category}`;
+        insertCategory.run(id, category, 'status', statusCategoryDescriptions[category] || null, i, now);
+    }
+}
 /**
  * Update board timestamp for a project.
  */

package/dist/lib/pmo/storage/categories.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Category operations.
+ * Manages ticket and status categories.
+ */
+import { Category, CategoryFilter, CategoryType } from '../types.js';
+import { StorageContext } from './types.js';
+export declare class CategoryStorage {
+    private ctx;
+    constructor(ctx: StorageContext);
+    /**
+     * List categories.
+     */
+    listCategories(filter?: CategoryFilter): Promise<Category[]>;
+    /**
+     * Get a category by ID.
+     */
+    getCategory(id: string): Promise<Category | null>;
+    /**
+     * Get a category by name and type.
+     */
+    getCategoryByName(name: string, type: CategoryType): Promise<Category | null>;
+    /**
+     * Create a new category.
+     */
+    createCategory(category: Partial<Category> & {
+        name: string;
+        type: CategoryType;
+    }): Promise<Category>;
+    /**
+     * Update a category.
+     */
+    updateCategory(id: string, changes: Partial<Category>): Promise<Category>;
+    /**
+     * Rename a category.
+     */
+    renameCategory(id: string, newName: string): Promise<Category>;
+    /**
+     * Delete a category.
+     */
+    deleteCategory(id: string): Promise<void>;
+    /**
+     * Get category names for a type (for validation and autocomplete).
+     */
+    getCategoryNames(type: CategoryType): Promise<string[]>;
+    /**
+     * Check if a category name is valid for a type.
+     */
+    isValidCategory(name: string, type: CategoryType): Promise<boolean>;
+    private rowToCategory;
+}