@proletariat/cli 0.3.10 → 0.3.12

package/dist/lib/themes.js

@@ -245,8 +245,8 @@ export function pickRandomThemeName() {
 }
 /**
  * Generate a unique ephemeral agent name.
- * Format: {adjective}-{theme_name}-{number}
- * Example: "bold-bezos-1", "keen-camry-2"
+ * Format: {adjective}-{theme_name} or {adjective}-{theme_name}-{number}
+ * Example: "bold-bezos", "keen-camry", "bold-bezos-2" (if bold-bezos exists)
  *
  * @param existingNames - Set of existing agent names (for uniqueness checking)
  * @param options - Optional configuration for name generation
@@ -259,25 +259,55 @@ export function generateEphemeralAgentName(existingNames, options) {
     const maxAttempts = 100;
     // Use specified theme or default (no mixing themes)
     const themeId = opts.themeId ?? DEFAULT_EPHEMERAL_THEME;
+    // Get all theme names and partition into preferred (unused) and fallback (in use)
+    const theme = BUILTIN_THEMES.find(t => t.id === themeId) ?? BUILTIN_THEMES[0];
+    const allBaseNames = [...theme.names];
+    const inUseBaseNames = opts.inUseBaseNames ?? new Set();
+    // Shuffle arrays for randomness
+    const shuffleArray = (arr) => {
+        const shuffled = [...arr];
+        for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled;
+    };
+    // Helper to check if a candidate name is available
+    const isAvailable = (candidateName) => {
+        // Check database/in-memory conflicts first
+        if (existingNames.has(candidateName.toLowerCase())) {
+            return false;
+        }
+        // Check external resource conflicts if callback provided
+        if (opts.checkExternalConflict) {
+            const result = opts.checkExternalConflict(candidateName);
+            if (result.conflict) {
+                opts.onConflictSkipped?.(candidateName, result.reason ?? 'external conflict');
+                return false;
+            }
+        }
+        return true;
+    };
+    // Partition base names: prefer unused ones first
+    const unusedBaseNames = shuffleArray(allBaseNames.filter(name => !inUseBaseNames.has(name.toLowerCase())));
+    const usedBaseNames = shuffleArray(allBaseNames.filter(name => inUseBaseNames.has(name.toLowerCase())));
+    // Try unused base names first, then fall back to used ones
+    const orderedBaseNames = [...unusedBaseNames, ...usedBaseNames];
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
         const adjective = pickAdjective();
-        const themeName = pickThemeName(themeId);
-        // Try finding a unique number suffix (4 digits max)
-        for (let num = 1; num <= 9999; num++) {
+        // Pick base name: cycle through ordered list based on attempt
+        const themeName = orderedBaseNames[attempt % orderedBaseNames.length];
+        // First try without a number suffix: "bold-bezos"
+        const nameWithoutNumber = `${adjective}-${themeName}`;
+        if (isAvailable(nameWithoutNumber)) {
+            return nameWithoutNumber;
+        }
+        // If taken, try with number suffixes: "bold-bezos-2", "bold-bezos-3", etc.
+        for (let num = 2; num <= 9999; num++) {
             const candidateName = `${adjective}-${themeName}-${num}`;
-            // Check database/in-memory conflicts first
-            if (existingNames.has(candidateName.toLowerCase())) {
-                continue;
+            if (isAvailable(candidateName)) {
+                return candidateName;
             }
-            // Check external resource conflicts if callback provided
-            if (opts.checkExternalConflict) {
-                const result = opts.checkExternalConflict(candidateName);
-                if (result.conflict) {
-                    opts.onConflictSkipped?.(candidateName, result.reason ?? 'external conflict');
-                    continue;
-                }
-            }
-            return candidateName;
         }
     }
     // Fallback: use timestamp if all attempts fail
@@ -286,16 +316,43 @@ export function generateEphemeralAgentName(existingNames, options) {
 }
 /**
  * Check if a name looks like an ephemeral agent name.
- * Ephemeral names follow pattern: {adjective}-{name}-{number}
+ * Ephemeral names follow pattern: {adjective}-{name} or {adjective}-{name}-{number}
  */
 export function isEphemeralAgentName(name) {
     const parts = name.split('-');
-    if (parts.length < 3)
-        return false;
-    const lastPart = parts[parts.length - 1];
-    const num = parseInt(lastPart, 10);
-    if (isNaN(num) || num < 1)
+    // Need at least 2 parts: adjective-baseName
+    if (parts.length < 2)
         return false;
     const adjective = parts[0].toLowerCase();
     return AGENT_ADJECTIVES.includes(adjective);
 }
+/**
+ * Extract the base name from an ephemeral agent name.
+ * Handles both formats: "bold-bezos" -> "bezos", "bold-bezos-2" -> "bezos"
+ */
+export function extractBaseName(agentName) {
+    const parts = agentName.split('-');
+    if (parts.length < 2)
+        return agentName;
+    // Check if last part is a number
+    const lastPart = parts[parts.length - 1];
+    const hasNumber = !isNaN(parseInt(lastPart, 10)) && parts.length >= 3;
+    // If has number: adjective-baseName-number -> baseName is middle parts
+    // If no number: adjective-baseName -> baseName is everything after adjective
+    return hasNumber
+        ? parts.slice(1, -1).join('-')
+        : parts.slice(1).join('-');
+}
+/**
+ * Get the base name for any agent type.
+ * - If agent has explicit base_name, use it
+ * - If ephemeral, extract from name pattern
+ * - Otherwise (staff), use agent name directly
+ */
+export function getAgentBaseName(agent) {
+    if (agent.base_name)
+        return agent.base_name;
+    if (agent.type === 'ephemeral')
+        return extractBaseName(agent.name);
+    return agent.name;
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Workspace Config (config.json) Management
+ *
+ * Reads and writes settings from .proletariat/config.json.
+ * This is distinct from execution config (stored in database).
+ *
+ * Config structure:
+ * {
+ *   "type": "hq",
+ *   "name": "workspace-name",
+ *   "version": "1.0.0",
+ *   "schemaVersion": 1,
+ *   "prlt": {
+ *     "channel": "npm" | "npm:dev" | "gh" | "gh:dev" | "mount"
+ *   }
+ * }
+ */
+/**
+ * prlt channel options:
+ *
+ * Public npm (npmjs.com) - no auth required:
+ * - "npm": Install @proletariat/cli@latest from public npm (default)
+ * - "npm:dev": Install @proletariat/cli@dev from public npm
+ * - "npm:next": Install @proletariat/cli@next from public npm
+ * - "npm:x.y.z": Install specific version from public npm
+ *
+ * Local development:
+ * - "mount": Mount local prlt build from PRLT_REPO_PATH
+ *
+ * Legacy (deprecated, now uses npm):
+ * - "gh": Alias for npm (GitHub Packages no longer used)
+ */
+export type PrltChannel = 'npm' | 'npm:dev' | 'npm:next' | 'gh' | 'gh:dev' | 'mount' | string;
+export interface PrltConfig {
+    /** prlt source: "npm", "npm:dev", "gh", "gh:dev", "mount", or specific version like "npm:1.2.3" */
+    channel?: PrltChannel;
+}
+export interface WorkspaceConfig {
+    type: 'hq' | 'workspace';
+    name: string;
+    version?: string;
+    schemaVersion?: number;
+    /** prlt CLI configuration for containers */
+    prlt?: PrltConfig;
+}
+/**
+ * Read workspace config from .proletariat/config.json
+ */
+export declare function readWorkspaceConfig(hqPath: string): WorkspaceConfig | null;
+/**
+ * Write workspace config to .proletariat/config.json
+ */
+export declare function writeWorkspaceConfig(hqPath: string, config: WorkspaceConfig): void;
+/**
+ * Get prlt config from workspace, with defaults
+ */
+export declare function getPrltConfig(hqPath: string): PrltConfig;
+/**
+ * Update prlt config section
+ */
+export declare function updatePrltConfig(hqPath: string, prltConfig: Partial<PrltConfig>): void;
+/**
+ * Get the prlt channel to use for container builds.
+ * Priority: override > workspace config > default "npm"
+ */
+export declare function getPrltChannel(hqPath: string, override?: string): string;
+/**
+ * Parse a prlt channel string into registry and version components.
+ * Examples:
+ *   "npm" -> { registry: "npm", version: "latest" }
+ *   "npm:dev" -> { registry: "npm", version: "dev" }
+ *   "npm:1.2.3" -> { registry: "npm", version: "1.2.3" }
+ *   "gh" -> { registry: "gh", version: "latest" }
+ *   "gh:dev" -> { registry: "gh", version: "dev" }
+ *   "mount" -> { registry: "mount", version: null }
+ */
+export declare function parseChannel(channel: string): {
+    registry: 'npm' | 'gh' | 'mount';
+    version: string | null;
+};

package/dist/lib/workspace-config.js

@@ -0,0 +1,100 @@
+/**
+ * Workspace Config (config.json) Management
+ *
+ * Reads and writes settings from .proletariat/config.json.
+ * This is distinct from execution config (stored in database).
+ *
+ * Config structure:
+ * {
+ *   "type": "hq",
+ *   "name": "workspace-name",
+ *   "version": "1.0.0",
+ *   "schemaVersion": 1,
+ *   "prlt": {
+ *     "channel": "npm" | "npm:dev" | "gh" | "gh:dev" | "mount"
+ *   }
+ * }
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+/**
+ * Read workspace config from .proletariat/config.json
+ */
+export function readWorkspaceConfig(hqPath) {
+    const configPath = path.join(hqPath, '.proletariat', 'config.json');
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write workspace config to .proletariat/config.json
+ */
+export function writeWorkspaceConfig(hqPath, config) {
+    const configPath = path.join(hqPath, '.proletariat', 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+/**
+ * Get prlt config from workspace, with defaults
+ */
+export function getPrltConfig(hqPath) {
+    const config = readWorkspaceConfig(hqPath);
+    return config?.prlt ?? {};
+}
+/**
+ * Update prlt config section
+ */
+export function updatePrltConfig(hqPath, prltConfig) {
+    const config = readWorkspaceConfig(hqPath);
+    if (!config) {
+        throw new Error('No workspace config found');
+    }
+    config.prlt = {
+        ...config.prlt,
+        ...prltConfig,
+    };
+    writeWorkspaceConfig(hqPath, config);
+}
+/**
+ * Get the prlt channel to use for container builds.
+ * Priority: override > workspace config > default "npm"
+ */
+export function getPrltChannel(hqPath, override) {
+    if (override) {
+        return override;
+    }
+    const prltConfig = getPrltConfig(hqPath);
+    return prltConfig.channel ?? 'npm';
+}
+/**
+ * Parse a prlt channel string into registry and version components.
+ * Examples:
+ *   "npm" -> { registry: "npm", version: "latest" }
+ *   "npm:dev" -> { registry: "npm", version: "dev" }
+ *   "npm:1.2.3" -> { registry: "npm", version: "1.2.3" }
+ *   "gh" -> { registry: "gh", version: "latest" }
+ *   "gh:dev" -> { registry: "gh", version: "dev" }
+ *   "mount" -> { registry: "mount", version: null }
+ */
+export function parseChannel(channel) {
+    if (channel === 'mount') {
+        return { registry: 'mount', version: null };
+    }
+    if (channel.startsWith('gh')) {
+        const version = channel.includes(':') ? channel.split(':')[1] : 'latest';
+        return { registry: 'gh', version };
+    }
+    // Default to npm
+    if (channel.startsWith('npm')) {
+        const version = channel.includes(':') ? channel.split(':')[1] : 'latest';
+        return { registry: 'npm', version };
+    }
+    // Bare version numbers default to npm
+    return { registry: 'npm', version: channel };
+}