@proletariat/cli 0.2.0 → 0.3.0

package/dist/lib/init/index.js

@@ -0,0 +1,355 @@
+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 { ensureBuiltinThemes, getThemePersistentDir, getThemeEphemeralDir } from '../themes.js';
+import { createAgentWorktrees } from '../agents/index.js';
+import { addRepositoriesToHQ, isInGitRepo } from '../repos/index.js';
+import { createPMO, } from '../pmo/index.js';
+import { createWorkspaceDatabase, addRepositoriesToDatabase, addAgentsToDatabase, createTheme, addThemeNames, setActiveTheme } from '../database/index.js';
+import { ensureMachineConfigDir, registerHeadquarters, getOrganizations, createOrganization, } from '../machine-config.js';
+/**
+ * Validate that HQ path is not inside a git repository or another HQ
+ * Returns: { valid: true } or { valid: false, reason: string }
+ */
+export function validateHQLocation(location) {
+    const resolvedPath = path.resolve(location);
+    const parentDir = path.dirname(resolvedPath);
+    // Check if inside a git repo
+    try {
+        const gitRoot = execSync('git rev-parse --show-toplevel', {
+            cwd: parentDir,
+            stdio: 'pipe',
+            encoding: 'utf-8'
+        }).trim();
+        // Use realpath to resolve symlinks and /private prefix on macOS
+        const normalizedPath = fs.realpathSync(parentDir);
+        const normalizedGitRoot = fs.realpathSync(gitRoot);
+        if (normalizedPath.startsWith(normalizedGitRoot)) {
+            return { valid: false, reason: 'inside-git' };
+        }
+    }
+    catch {
+        // Not in a git repo - this is fine
+    }
+    // Check if inside an existing HQ (look for .proletariat/config.json with type: 'hq')
+    // Note: ~/.proletariat is the machine config, not an HQ, so we check the config type
+    let checkDir = parentDir;
+    while (checkDir !== '/' && checkDir !== path.dirname(checkDir)) {
+        const configPath = path.join(checkDir, '.proletariat', 'config.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                if (config.type === 'hq') {
+                    return { valid: false, reason: 'inside-hq' };
+                }
+            }
+            catch {
+                // Invalid JSON, skip
+            }
+        }
+        checkDir = path.dirname(checkDir);
+    }
+    return { valid: true };
+}
+/**
+ * Prompt user for HQ name
+ */
+export async function promptForHQName() {
+    const inGitRepo = isInGitRepo();
+    const defaultName = inGitRepo
+        ? path.basename(process.cwd()) // Use repo name as default
+        : ''; // No default outside repo
+    const { name } = await inquirer.prompt([{
+            type: 'input',
+            name: 'name',
+            message: 'HQ name (company, project, or team name):',
+            default: defaultName,
+            validate: (input) => {
+                if (!input.trim())
+                    return 'Name is required';
+                if (!/^[a-zA-Z0-9-_]+$/.test(input)) {
+                    return 'Name can only contain letters, numbers, hyphens, and underscores';
+                }
+                return true;
+            },
+        }]);
+    return name;
+}
+/**
+ * Check if current directory is inside an HQ and return the HQ root path
+ */
+function findContainingHQ() {
+    let checkDir = process.cwd();
+    while (checkDir !== '/' && checkDir !== path.dirname(checkDir)) {
+        const configPath = path.join(checkDir, '.proletariat', 'config.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+                if (config.type === 'hq') {
+                    return checkDir;
+                }
+            }
+            catch {
+                // Invalid JSON, skip
+            }
+        }
+        checkDir = path.dirname(checkDir);
+    }
+    return null;
+}
+/**
+ * Prompt user for HQ location
+ */
+export async function promptForHQLocation(hqName) {
+    const inGitRepo = isInGitRepo();
+    const containingHQ = findContainingHQ();
+    const folderName = `${hqName}-hq`;
+    // Determine default path based on context
+    let defaultPath;
+    if (containingHQ) {
+        // Inside an HQ - suggest sibling to the HQ
+        defaultPath = path.join(path.dirname(containingHQ), folderName);
+    }
+    else if (inGitRepo) {
+        // Inside a git repo - suggest sibling to repo
+        defaultPath = path.join('..', folderName);
+    }
+    else {
+        // Nowhere special - suggest subdirectory
+        defaultPath = `./${folderName}`;
+    }
+    while (true) {
+        const { location } = await inquirer.prompt([{
+                type: 'input',
+                name: 'location',
+                message: `Where to create HQ [press Enter for ${defaultPath}]:`,
+                default: defaultPath,
+            }]);
+        // Validate location
+        const validation = validateHQLocation(location);
+        if (!validation.valid) {
+            if (validation.reason === 'inside-git') {
+                console.log(chalk.red('Cannot create HQ inside a git repository.'));
+            }
+            else if (validation.reason === 'inside-hq') {
+                console.log(chalk.red('Cannot create HQ inside another HQ. No HQ-ception allowed!'));
+            }
+            continue;
+        }
+        // Check if directory already exists
+        const resolvedPath = path.resolve(location);
+        if (fs.existsSync(resolvedPath)) {
+            console.log(chalk.red(`Directory ${resolvedPath} already exists.`));
+            continue;
+        }
+        return resolvedPath;
+    }
+}
+/**
+ * Prompt user for organization selection or creation
+ */
+export async function promptForOrganization() {
+    const existingOrgs = getOrganizations();
+    if (existingOrgs.length === 0) {
+        // First organization - prompt for name
+        const { orgName } = await inquirer.prompt([{
+                type: 'input',
+                name: 'orgName',
+                message: 'Organization name (company or team):',
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'Organization name is required';
+                    return true;
+                },
+            }]);
+        createOrganization(orgName.trim());
+        return orgName.trim();
+    }
+    // Show existing organizations with option to create new
+    const { choice } = await inquirer.prompt([{
+            type: 'list',
+            name: 'choice',
+            message: 'Select organization:',
+            choices: [
+                ...existingOrgs.map(o => ({ name: o.name, value: o.name })),
+                new inquirer.Separator(),
+                { name: '+ Create new organization', value: '__new__' },
+            ],
+        }]);
+    if (choice === '__new__') {
+        const { orgName } = await inquirer.prompt([{
+                type: 'input',
+                name: 'orgName',
+                message: 'New organization name:',
+                validate: (input) => {
+                    if (!input.trim())
+                        return 'Organization name is required';
+                    return true;
+                },
+            }]);
+        createOrganization(orgName.trim());
+        return orgName.trim();
+    }
+    return choice;
+}
+/**
+ * Create the basic HQ directory structure
+ *
+ * Structure:
+ * my-hq/
+ *   .proletariat/           # HQ config and database
+ *   repos/                  # Repositories
+ *   agents/
+ *     staff/                # Persistent agents
+ *     temp/                 # Ephemeral agents
+ */
+export function createHQStructure(hqPath, hqName, themeId, quiet) {
+    if (!quiet)
+        console.log(chalk.blue(`\n🏗️  Creating HQ at ${hqPath}...`));
+    // Get theme-specific directory names
+    const persistentDir = getThemePersistentDir(themeId);
+    const ephemeralDir = getThemeEphemeralDir(themeId);
+    // Create directories
+    fs.mkdirSync(hqPath, { recursive: true });
+    fs.mkdirSync(path.join(hqPath, '.proletariat'), { recursive: true });
+    fs.mkdirSync(path.join(hqPath, 'repos'), { recursive: true });
+    fs.mkdirSync(path.join(hqPath, 'agents'), { recursive: true });
+    fs.mkdirSync(path.join(hqPath, 'agents', persistentDir), { recursive: true });
+    fs.mkdirSync(path.join(hqPath, 'agents', ephemeralDir), { recursive: true });
+}
+/**
+ * Create HQ database and config
+ */
+export function initializeHQDatabase(hqPath, options) {
+    if (!options.pmoSetup || !options.hqName) {
+        throw new Error('initializeHQDatabase requires hqName and pmoSetup to be defined');
+    }
+    const hasPMO = options.pmoSetup.includePMO;
+    // Create the database with HQ configuration
+    const db = createWorkspaceDatabase(hqPath, 'hq', options.hqName, hasPMO);
+    db.close();
+    // Create HQ config.json (required for HQ detection)
+    const configPath = path.join(hqPath, '.proletariat', 'config.json');
+    const config = {
+        version: "1.0.0",
+        schemaVersion: 1,
+        type: 'hq',
+        name: options.hqName
+    };
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+/** @deprecated Use initializeHQDatabase instead */
+export const initializeWorkspaceDatabase = initializeHQDatabase;
+/**
+ * Complete HQ initialization workflow
+ */
+export async function initializeHQ(options) {
+    const { hqPath, hqName, selectedAgents, repos, pmoSetup, themeId, customTheme, orgName, quiet, } = options;
+    // Helper to log only in non-quiet mode
+    const log = (message) => {
+        if (!quiet)
+            console.log(message);
+    };
+    // All these fields are required for HQ type
+    if (!hqPath || !hqName || repos === undefined || !pmoSetup) {
+        throw new Error('Missing required fields for HQ initialization');
+    }
+    // Create basic structure (pass hqName and themeId for correct directory names)
+    createHQStructure(hqPath, hqName, themeId, quiet);
+    // Create database and HQ configuration
+    initializeHQDatabase(hqPath, options);
+    // Ensure builtin themes exist
+    ensureBuiltinThemes(hqPath);
+    // Save custom theme if one was created during init
+    if (customTheme) {
+        createTheme(hqPath, {
+            id: customTheme.name,
+            name: customTheme.name,
+            displayName: customTheme.displayName,
+            builtin: false,
+        });
+        addThemeNames(hqPath, customTheme.name, customTheme.names);
+        log(chalk.blue(`Created custom theme: ${customTheme.displayName}`));
+    }
+    // Set active theme if one was selected
+    if (themeId) {
+        setActiveTheme(hqPath, themeId);
+    }
+    // Handle repositories - add to file system AND database
+    const addedRepos = await addRepositoriesToHQ(hqPath, repos);
+    // Convert to database format
+    const dbRepos = addedRepos.map(repoName => {
+        const repoData = repos.find(r => path.basename(r.path).replace(/\.git$/, '') === repoName);
+        return {
+            name: repoName,
+            path: `repos/${repoName}`,
+            source_url: repoData?.path,
+            action: repoData?.action
+        };
+    });
+    addRepositoriesToDatabase(hqPath, dbRepos);
+    // Create PMO if requested
+    if (pmoSetup.includePMO) {
+        await createPMO({
+            hqPath,
+            location: pmoSetup.location,
+            boardTemplate: pmoSetup.boardTemplate,
+            boardName: pmoSetup.boardName,
+            columns: pmoSetup.columns,
+            storageType: pmoSetup.storageType,
+        });
+    }
+    // Add agents if selected - create worktrees AND add to database
+    if (selectedAgents.length > 0) {
+        const persistentDir = getThemePersistentDir(themeId);
+        const agentsPath = path.join(hqPath, 'agents', persistentDir);
+        // Create physical worktrees
+        await createAgentWorktrees(agentsPath, selectedAgents, hqPath);
+        // Add to database
+        addAgentsToDatabase(hqPath, selectedAgents);
+    }
+    // Register headquarters in machine config
+    ensureMachineConfigDir();
+    registerHeadquarters(hqPath, hqName, true, orgName);
+    log(chalk.gray(`Registered headquarters in ~/.proletariat/config.json`));
+    log(chalk.green(`\n✅ Headquarters created successfully at ${hqPath}`));
+}
+/**
+ * Show next steps to user
+ */
+export async function showNextSteps(options) {
+    const relativePath = path.relative(process.cwd(), options.hqPath);
+    const hasPMO = options.pmoSetup?.includePMO ?? false;
+    // Show navigation instructions
+    console.log(chalk.blue(`\n📂 Your headquarters is ready! Navigate to it:`));
+    console.log(chalk.yellow(`  cd ${relativePath}`));
+    // Ask if they want to see the next steps
+    const { showNextSteps } = await inquirer.prompt([{
+            type: 'list',
+            name: 'showNextSteps',
+            message: 'Show additional next steps?',
+            choices: [
+                { name: 'Yes', value: true },
+                { name: 'No', value: false }
+            ],
+            default: true,
+        }]);
+    // Show additional next steps if requested
+    if (showNextSteps) {
+        const hasCommands = (options.selectedAgents.length === 0) || hasPMO;
+        if (hasCommands) {
+            console.log(chalk.cyan(`\nOnce you're in the headquarters, you can run:`));
+            if (options.selectedAgents.length === 0) {
+                console.log(chalk.white(`  prlt agent add <name>`));
+            }
+            if (hasPMO) {
+                console.log(chalk.white(`  prlt ticket create`));
+            }
+        }
+        else {
+            console.log(chalk.green(`\nYour headquarters is fully set up and ready to use!`));
+        }
+    }
+}

package/dist/lib/machine-config.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Machine-level configuration for Proletariat headquarters.
+ *
+ * This module manages the ~/.proletariat/config.json registry that tracks
+ * all known headquarters on the machine, solving the HQ discovery
+ * chicken-and-egg problem.
+ *
+ * Registry schema:
+ * {
+ *   "version": "1.0.0",
+ *   "headquarters": [
+ *     { "name": "hq-name", "path": "/absolute/path", "registeredAt": "ISO8601" }
+ *   ],
+ *   "activeHeadquarters": "/absolute/path" | null
+ * }
+ */
+export interface Organization {
+    name: string;
+    createdAt: string;
+}
+export interface RegisteredHeadquarters {
+    name: string;
+    path: string;
+    registeredAt: string;
+    orgName?: string;
+}
+/** @deprecated Use RegisteredHeadquarters instead */
+export type RegisteredWorkspace = RegisteredHeadquarters;
+export interface MachineConfig {
+    type: 'machine';
+    version: string;
+    organizations: Organization[];
+    headquarters: RegisteredHeadquarters[];
+    activeHeadquarters: string | null;
+    activeOrganization: string | null;
+    /** @deprecated Use headquarters instead */
+    workspaces?: RegisteredHeadquarters[];
+    /** @deprecated Use activeHeadquarters instead */
+    activeWorkspace?: string | null;
+}
+/**
+ * Get the path to the machine-level config directory (~/.proletariat/).
+ */
+export declare function getMachineConfigDir(): string;
+/**
+ * Get the path to the machine-level config file (~/.proletariat/config.json).
+ */
+export declare function getMachineConfigPath(): string;
+/**
+ * Ensure the machine config directory exists.
+ * Creates ~/.proletariat/ if it doesn't exist.
+ */
+export declare function ensureMachineConfigDir(): void;
+/**
+ * Normalize a workspace path for consistent storage.
+ * - Resolves symlinks
+ * - Makes path absolute
+ * - Removes trailing slashes
+ */
+export declare function normalizePath(inputPath: string): string;
+/**
+ * Read the machine config file.
+ * Returns a default empty config if file doesn't exist or is invalid.
+ * Handles migration from old 'workspaces' format to new 'headquarters' format.
+ */
+export declare function readMachineConfig(): MachineConfig;
+/**
+ * Write the machine config file atomically.
+ * Uses write-to-temp-then-rename pattern for safety.
+ */
+export declare function writeMachineConfig(config: MachineConfig): void;
+/**
+ * Register a headquarters in the machine config.
+ *
+ * @param hqPath Absolute path to the headquarters (will be normalized)
+ * @param name Optional HQ name (defaults to directory basename)
+ * @param setActive If true, set as active HQ when no active HQ exists
+ * @param orgName Optional organization name to associate this HQ with
+ * @returns The registered headquarters entry
+ */
+export declare function registerHeadquarters(hqPath: string, name?: string, setActive?: boolean, orgName?: string): RegisteredHeadquarters;
+/** @deprecated Use registerHeadquarters instead */
+export declare const registerWorkspace: typeof registerHeadquarters;
+/**
+ * Unregister a headquarters from the machine config.
+ *
+ * @param pathOrName HQ path or name to unregister
+ * @returns true if HQ was found and removed, false otherwise
+ */
+export declare function unregisterHeadquarters(pathOrName: string): boolean;
+/** @deprecated Use unregisterHeadquarters instead */
+export declare const unregisterWorkspace: typeof unregisterHeadquarters;
+/**
+ * Get all registered headquarters.
+ */
+export declare function getRegisteredHeadquarters(): RegisteredHeadquarters[];
+/** @deprecated Use getRegisteredHeadquarters instead */
+export declare const getRegisteredWorkspaces: typeof getRegisteredHeadquarters;
+/**
+ * Get the active headquarters path.
+ * Returns null if no active HQ is set.
+ */
+export declare function getActiveHeadquarters(): string | null;
+/** @deprecated Use getActiveHeadquarters instead */
+export declare const getActiveWorkspace: typeof getActiveHeadquarters;
+/**
+ * Set the active headquarters.
+ *
+ * @param pathOrName HQ path or name
+ * @returns The path of the HQ that was set as active
+ * @throws Error if HQ not found or not valid
+ */
+export declare function setActiveHeadquarters(pathOrName: string): string;
+/** @deprecated Use setActiveHeadquarters instead */
+export declare const setActiveWorkspace: typeof setActiveHeadquarters;
+/**
+ * Find headquarters by name.
+ * Returns array of matches (may be multiple if names are not unique).
+ */
+export declare function findHeadquartersByName(name: string): RegisteredHeadquarters[];
+/** @deprecated Use findHeadquartersByName instead */
+export declare const findWorkspacesByName: typeof findHeadquartersByName;
+/**
+ * Find headquarters by path.
+ */
+export declare function findHeadquartersByPath(hqPath: string): RegisteredHeadquarters | null;
+/** @deprecated Use findHeadquartersByPath instead */
+export declare const findWorkspaceByPath: typeof findHeadquartersByPath;
+/**
+ * Check if a headquarters path is registered.
+ */
+export declare function isHeadquartersRegistered(hqPath: string): boolean;
+/** @deprecated Use isHeadquartersRegistered instead */
+export declare const isWorkspaceRegistered: typeof isHeadquartersRegistered;
+/**
+ * Get headquarters name from path (for existing HQ).
+ * Reads the HQ config to get the name, or falls back to directory basename.
+ */
+export declare function getHeadquartersNameFromPath(hqPath: string): string;
+/** @deprecated Use getHeadquartersNameFromPath instead */
+export declare const getWorkspaceNameFromPath: typeof getHeadquartersNameFromPath;
+/**
+ * Check if there are duplicate headquarters names in the registry.
+ */
+export declare function hasDuplicateNames(): {
+    name: string;
+    paths: string[];
+}[];
+/**
+ * Get all organizations.
+ */
+export declare function getOrganizations(): Organization[];
+/**
+ * Get the active organization name.
+ */
+export declare function getActiveOrganization(): string | null;
+/**
+ * Create a new organization.
+ */
+export declare function createOrganization(name: string): Organization;
+/**
+ * Set the active organization.
+ */
+export declare function setActiveOrganization(name: string): void;
+/**
+ * Get headquarters belonging to a specific organization.
+ */
+export declare function getOrganizationHeadquarters(orgName: string): RegisteredHeadquarters[];
+/** @deprecated Use getOrganizationHeadquarters instead */
+export declare const getOrganizationWorkspaces: typeof getOrganizationHeadquarters;