fitout 0.1.0

package/dist/profiles.d.ts

@@ -0,0 +1,19 @@
+import { FettleConfig } from './config.js';
+export interface ResolvedPlugin {
+    id: string;
+    source: string;
+    constraint: string | null;
+}
+export interface ConstraintOverride {
+    pluginId: string;
+    projectConstraint: string;
+    winningConstraint: string;
+    winningSource: string;
+}
+export interface ProfileResolutionResult {
+    plugins: ResolvedPlugin[];
+    errors: string[];
+    constraintOverrides: ConstraintOverride[];
+}
+export declare function loadProfile(profilesDir: string, name: string): string[] | null;
+export declare function resolveProfiles(profilesDir: string, config: FettleConfig): ProfileResolutionResult;

package/dist/profiles.js

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'smol-toml';
+import { parsePluginList, mergeConstraints } from './constraint.js';
+export function loadProfile(profilesDir, name) {
+    const profilePath = join(profilesDir, `${name}.toml`);
+    if (!existsSync(profilePath)) {
+        return null;
+    }
+    const content = readFileSync(profilePath, 'utf-8');
+    const parsed = parse(content);
+    const plugins = Array.isArray(parsed.plugins)
+        ? parsed.plugins.filter((p) => typeof p === 'string')
+        : [];
+    return plugins;
+}
+export function resolveProfiles(profilesDir, config) {
+    const errors = [];
+    const constraintOverrides = [];
+    const pluginMap = new Map();
+    // Track project constraints for override detection
+    const projectConstraints = new Map();
+    // Helper to add plugins with constraint merging
+    const addPlugins = (pluginStrings, source) => {
+        const parseResult = parsePluginList(pluginStrings);
+        // Collect parse errors
+        for (const error of parseResult.errors) {
+            errors.push(`${error.input}: ${error.message}`);
+        }
+        for (const parsed of parseResult.plugins) {
+            const existing = pluginMap.get(parsed.id);
+            if (existing) {
+                // Plugin exists - merge constraints (higher wins)
+                const merged = mergeConstraints(existing.constraint, parsed.constraint);
+                // Track if project constraint was overridden
+                if (source === 'project' && parsed.constraint !== null) {
+                    projectConstraints.set(parsed.id, parsed.constraint);
+                }
+                // Check if project's constraint is being overridden by profile
+                const projectConstraint = projectConstraints.get(parsed.id);
+                if (projectConstraint &&
+                    existing.constraint !== null &&
+                    merged === existing.constraint &&
+                    merged !== projectConstraint) {
+                    constraintOverrides.push({
+                        pluginId: parsed.id,
+                        projectConstraint,
+                        winningConstraint: merged,
+                        winningSource: existing.source,
+                    });
+                }
+                existing.constraint = merged;
+            }
+            else {
+                pluginMap.set(parsed.id, {
+                    id: parsed.id,
+                    source,
+                    constraint: parsed.constraint,
+                });
+                // Track project constraints
+                if (source === 'project' && parsed.constraint !== null) {
+                    projectConstraints.set(parsed.id, parsed.constraint);
+                }
+            }
+        }
+    };
+    // 1. Auto-include default if exists
+    const defaultPlugins = loadProfile(profilesDir, 'default');
+    if (defaultPlugins !== null) {
+        addPlugins(defaultPlugins, 'default');
+    }
+    // 2. Load explicit profiles
+    for (const profileName of config.profiles) {
+        const profilePlugins = loadProfile(profilesDir, profileName);
+        if (profilePlugins === null) {
+            errors.push(`Profile not found: ${profileName}`);
+        }
+        else {
+            addPlugins(profilePlugins, profileName);
+        }
+    }
+    // 3. Add project plugins
+    addPlugins(config.plugins, 'project');
+    return {
+        plugins: Array.from(pluginMap.values()),
+        errors,
+        constraintOverrides,
+    };
+}

package/dist/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare function confirm(question: string, defaultValue?: boolean): Promise<boolean>;
+export declare function input(question: string, defaultValue?: string): Promise<string>;

package/dist/prompt.js

@@ -0,0 +1,52 @@
+// src/prompt.ts
+import * as readline from 'node:readline';
+export async function confirm(question, defaultValue = true) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const hint = defaultValue ? '(Y/n)' : '(y/N)';
+    return new Promise((resolve) => {
+        let answered = false;
+        rl.on('close', () => {
+            if (!answered) {
+                // Ctrl+C pressed - exit cleanly
+                console.log('');
+                process.exit(130);
+            }
+        });
+        rl.question(`${question} ${hint} `, (answer) => {
+            answered = true;
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            if (trimmed === '') {
+                resolve(defaultValue);
+            }
+            else {
+                resolve(trimmed === 'y' || trimmed === 'yes');
+            }
+        });
+    });
+}
+export async function input(question, defaultValue = '') {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const hint = defaultValue ? ` [${defaultValue}]` : '';
+    return new Promise((resolve) => {
+        let answered = false;
+        rl.on('close', () => {
+            if (!answered) {
+                // Ctrl+C pressed - exit cleanly
+                console.log('');
+                process.exit(130);
+            }
+        });
+        rl.question(`${question}${hint}: `, (answer) => {
+            answered = true;
+            rl.close();
+            resolve(answer.trim() || defaultValue);
+        });
+    });
+}

package/dist/status.d.ts

@@ -0,0 +1,22 @@
+import { PluginDiff, PluginDiffResolved } from './diff.js';
+import { ConstraintOverride } from './profiles.js';
+import { OutdatedPlugin } from './update.js';
+import { HookStatus } from './init.js';
+export interface StatusOptions {
+    refresh?: boolean;
+}
+export interface GlobalStatus {
+    hookStatus: HookStatus;
+    skillInstalled: boolean;
+    profiles: string[];
+}
+export declare function formatGlobalStatus(status: GlobalStatus): string;
+export interface StatusDiff extends PluginDiffResolved {
+    outdated: OutdatedPlugin[];
+}
+export declare function formatStatusResolved(diff: StatusDiff, showRefreshTip: boolean, constraintOverrides?: ConstraintOverride[]): string;
+export declare function formatStatus(diff: PluginDiff): string;
+export declare function runStatus(cwd: string, options?: StatusOptions): {
+    output: string;
+    exitCode: number;
+};

package/dist/status.js

@@ -0,0 +1,179 @@
+import { readFileSync } from 'node:fs';
+import { findConfigPath, resolveProjectRoot, getProfilesDir } from './context.js';
+import { parseConfig } from './config.js';
+import { listPlugins } from './claude.js';
+import { diffPluginsResolved } from './diff.js';
+import { resolveProfiles } from './profiles.js';
+import { colors, symbols, provenanceColor, formatContextLine } from './colors.js';
+import { listAvailablePlugins, refreshMarketplaces } from './marketplace.js';
+import { findOutdatedPlugins } from './update.js';
+import { readClaudeSettings, getFitoutHookStatus, hasFitoutSkill } from './init.js';
+import { getClaudeSettingsPath } from './paths.js';
+export function formatGlobalStatus(status) {
+    const lines = [];
+    lines.push(colors.header('Global:'));
+    if (status.hookStatus === 'current') {
+        lines.push(`  ${symbols.present} Hook installed`);
+    }
+    else if (status.hookStatus === 'outdated') {
+        lines.push(`  ${symbols.outdated} Hook outdated ${colors.dim('(run `fitout init` to upgrade)')}`);
+    }
+    else {
+        lines.push(`  ${symbols.missing} Hook ${colors.dim('(run `fitout init`)')}`);
+    }
+    if (status.skillInstalled) {
+        lines.push(`  ${symbols.present} Skill installed`);
+    }
+    else {
+        lines.push(`  ${symbols.missing} Skill ${colors.dim('(run `fitout init`)')}`);
+    }
+    if (status.profiles.length > 0) {
+        const profileList = status.profiles.map(p => provenanceColor(p)(p)).join(', ');
+        lines.push(`  ${symbols.present} Profiles: ${profileList}`);
+    }
+    return lines.join('\n');
+}
+function formatProvenance(source) {
+    if (source === 'project')
+        return '';
+    const colorFn = provenanceColor(source);
+    return ' ' + colorFn(`(from: ${source})`);
+}
+export function formatStatusResolved(diff, showRefreshTip, constraintOverrides = []) {
+    const lines = [];
+    const outdatedIds = new Set(diff.outdated.map((p) => p.id));
+    for (const plugin of diff.present) {
+        const outdated = diff.outdated.find((o) => o.id === plugin.id);
+        const constraintStr = plugin.constraint ? ` >= ${plugin.constraint}` : '';
+        if (outdated) {
+            lines.push(`${symbols.outdated} ${plugin.id} ${colors.warning(`v${outdated.installedVersion} → v${outdated.availableVersion}`)}${constraintStr}${formatProvenance(plugin.source)} ${colors.warning('(outdated)')}`);
+        }
+        else {
+            const versionStr = plugin.version ? ` ${plugin.version}` : '';
+            lines.push(`${symbols.present} ${plugin.id}${versionStr}${constraintStr}${formatProvenance(plugin.source)}`);
+        }
+    }
+    for (const plugin of diff.missing) {
+        lines.push(`${symbols.missing} ${plugin.id}${formatProvenance(plugin.source)} ${colors.error('(missing)')}`);
+    }
+    for (const plugin of diff.extra) {
+        lines.push(`${symbols.extra} ${plugin.id} ${colors.warning('(not in config)')}`);
+    }
+    const upToDateCount = diff.present.length - diff.outdated.length;
+    const summary = [
+        upToDateCount > 0 ? colors.success(`${upToDateCount} present`) : null,
+        diff.outdated.length > 0 ? colors.warning(`${diff.outdated.length} outdated`) : null,
+        diff.missing.length > 0 ? colors.error(`${diff.missing.length} missing`) : null,
+        diff.extra.length > 0 ? colors.warning(`${diff.extra.length} extra`) : null,
+    ].filter(Boolean).join(', ');
+    lines.push('');
+    lines.push(summary || 'No plugins configured');
+    // Add tips when there are outdated plugins
+    if (diff.outdated.length > 0) {
+        lines.push('');
+        lines.push(colors.dim(`Tip: Run \`fitout update\` to update outdated plugins.`));
+        if (showRefreshTip) {
+            lines.push(colors.dim(`     Run \`fitout status --refresh\` to check for newer versions.`));
+        }
+    }
+    // Add constraint override warnings
+    if (constraintOverrides.length > 0) {
+        lines.push('');
+        lines.push(colors.header('Warnings:'));
+        for (const override of constraintOverrides) {
+            lines.push(`  ${override.pluginId}: constraint >= ${override.projectConstraint} (project) overridden by >= ${override.winningConstraint} (${override.winningSource})`);
+            lines.push(`    To fix: update .claude/fitout.toml to ">= ${override.winningConstraint}" or remove the constraint`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatStatus(diff) {
+    const lines = [];
+    for (const plugin of diff.present) {
+        lines.push(`${symbols.present} ${plugin.id}`);
+    }
+    for (const id of diff.missing) {
+        lines.push(`${symbols.missing} ${id} ${colors.error('(missing)')}`);
+    }
+    for (const plugin of diff.extra) {
+        lines.push(`${symbols.extra} ${plugin.id} ${colors.warning('(not in config)')}`);
+    }
+    const summary = [
+        diff.present.length > 0 ? colors.success(`${diff.present.length} present`) : null,
+        diff.missing.length > 0 ? colors.error(`${diff.missing.length} missing`) : null,
+        diff.extra.length > 0 ? colors.warning(`${diff.extra.length} extra`) : null,
+    ].filter(Boolean).join(', ');
+    lines.push('');
+    lines.push(summary || 'No plugins configured');
+    return lines.join('\n');
+}
+export function runStatus(cwd, options = {}) {
+    // Check global status
+    const settingsPath = getClaudeSettingsPath();
+    const settings = readClaudeSettings(settingsPath);
+    const hookStatus = getFitoutHookStatus(settings);
+    const skillInstalled = hasFitoutSkill();
+    const configPath = findConfigPath(cwd);
+    if (!configPath) {
+        // No project config - show global status and hint
+        const globalStatus = formatGlobalStatus({
+            hookStatus,
+            skillInstalled,
+            profiles: [],
+        });
+        return {
+            output: `${globalStatus}\n\nNo project config. Run \`fitout init\` to create one.`,
+            exitCode: 1,
+        };
+    }
+    const projectRoot = resolveProjectRoot(cwd);
+    // Refresh marketplaces if requested
+    if (options.refresh) {
+        console.log('Refreshing marketplaces...');
+        refreshMarketplaces();
+    }
+    let configContent;
+    let config;
+    try {
+        configContent = readFileSync(configPath, 'utf-8');
+        config = parseConfig(configContent);
+    }
+    catch (err) {
+        return {
+            output: `Failed to read config: ${err instanceof Error ? err.message : 'Unknown error'}`,
+            exitCode: 1,
+        };
+    }
+    // Resolve profiles
+    const profilesDir = getProfilesDir();
+    const resolution = resolveProfiles(profilesDir, config);
+    if (resolution.errors.length > 0) {
+        return {
+            output: `${colors.header('Profile errors:')}\n${resolution.errors.map((e) => `  ${symbols.missing} ${e}`).join('\n')}`,
+            exitCode: 1,
+        };
+    }
+    // Get list of profiles being used
+    const profiles = config.profiles || [];
+    const installed = listPlugins();
+    const available = listAvailablePlugins();
+    const diff = diffPluginsResolved(resolution.plugins, installed, projectRoot);
+    const outdated = findOutdatedPlugins(installed, available, projectRoot);
+    const statusDiff = {
+        ...diff,
+        outdated,
+    };
+    const showRefreshTip = !options.refresh;
+    const contextLine = formatContextLine(projectRoot, cwd);
+    // Format global status
+    const globalStatus = formatGlobalStatus({
+        hookStatus,
+        skillInstalled,
+        profiles,
+    });
+    const formatted = formatStatusResolved(statusDiff, showRefreshTip, resolution.constraintOverrides);
+    return {
+        output: `${globalStatus}\n\n${contextLine}${colors.header('Plugins:')}\n${formatted}`,
+        exitCode: diff.missing.length > 0 ? 1 : 0,
+    };
+}

package/dist/test-utils.d.ts

@@ -0,0 +1,8 @@
+export interface TestContext {
+    claudeHome: string;
+    fitoutHome: string;
+    baseDir: string;
+    cleanup: () => void;
+}
+export declare function setupTestEnv(): TestContext;
+export declare function cleanTestTmp(): void;

package/dist/test-utils.js

@@ -0,0 +1,33 @@
+// src/test-utils.ts
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { vi } from 'vitest';
+// Project-local temp directory (gitignored)
+const TEST_TMP_ROOT = join(import.meta.dirname, '..', '.test-tmp');
+let testCounter = 0;
+export function setupTestEnv() {
+    const testId = `${Date.now()}-${++testCounter}`;
+    const baseDir = join(TEST_TMP_ROOT, testId);
+    const claudeHome = join(baseDir, '.claude');
+    const fitoutHome = join(baseDir, '.config', 'fitout');
+    mkdirSync(claudeHome, { recursive: true });
+    mkdirSync(fitoutHome, { recursive: true });
+    vi.stubEnv('CLAUDE_CONFIG_DIR', claudeHome);
+    vi.stubEnv('FITOUT_CONFIG_HOME', fitoutHome);
+    return {
+        claudeHome,
+        fitoutHome,
+        baseDir,
+        cleanup: () => {
+            vi.unstubAllEnvs();
+        },
+    };
+}
+export function cleanTestTmp() {
+    try {
+        rmSync(TEST_TMP_ROOT, { recursive: true, force: true, maxRetries: 3 });
+    }
+    catch {
+        // Ignore errors - directory might be in use by parallel tests
+    }
+}

package/dist/update.d.ts

@@ -0,0 +1,28 @@
+import { InstalledPlugin } from './claude.js';
+import { AvailablePlugin } from './marketplace.js';
+export interface OutdatedPlugin {
+    id: string;
+    installedVersion: string;
+    availableVersion: string;
+    scope: 'local' | 'user' | 'global';
+    projectPath?: string;
+}
+/**
+ * Compare semver versions. Returns:
+ * -1 if a < b
+ *  0 if a == b
+ *  1 if a > b
+ */
+export declare function compareVersions(a: string, b: string): number;
+export declare function findOutdatedPlugins(installed: InstalledPlugin[], available: AvailablePlugin[], projectPath: string): OutdatedPlugin[];
+export declare function updatePlugin(pluginId: string, scope?: 'local' | 'user'): void;
+export interface UpdateOptions {
+    refresh?: boolean;
+    dryRun?: boolean;
+}
+export interface UpdateResult {
+    output: string;
+    exitCode: number;
+    pluginsToUpdate: OutdatedPlugin[];
+}
+export declare function runUpdate(projectPath: string, installed: InstalledPlugin[], available: AvailablePlugin[], pluginIds: string[], options?: UpdateOptions): UpdateResult;

package/dist/update.js

@@ -0,0 +1,108 @@
+import { execFileSync } from 'node:child_process';
+/**
+ * Compare semver versions. Returns:
+ * -1 if a < b
+ *  0 if a == b
+ *  1 if a > b
+ */
+export function compareVersions(a, b) {
+    const parseVersion = (v) => {
+        return v.split('.').map((n) => parseInt(n, 10) || 0);
+    };
+    const aParts = parseVersion(a);
+    const bParts = parseVersion(b);
+    const maxLen = Math.max(aParts.length, bParts.length);
+    for (let i = 0; i < maxLen; i++) {
+        const aVal = aParts[i] || 0;
+        const bVal = bParts[i] || 0;
+        if (aVal < bVal)
+            return -1;
+        if (aVal > bVal)
+            return 1;
+    }
+    return 0;
+}
+export function findOutdatedPlugins(installed, available, projectPath) {
+    const availableMap = new Map(available.map((p) => [p.id, p]));
+    const outdated = [];
+    // Filter to local plugins for this project
+    const localPlugins = installed.filter((p) => p.scope === 'local' && p.projectPath === projectPath);
+    for (const plugin of localPlugins) {
+        const avail = availableMap.get(plugin.id);
+        if (!avail)
+            continue;
+        // Skip if either version is missing
+        if (!plugin.version || !avail.version)
+            continue;
+        if (compareVersions(plugin.version, avail.version) < 0) {
+            outdated.push({
+                id: plugin.id,
+                installedVersion: plugin.version,
+                availableVersion: avail.version,
+                scope: plugin.scope,
+                projectPath: plugin.projectPath,
+            });
+        }
+    }
+    return outdated;
+}
+export function updatePlugin(pluginId, scope = 'local') {
+    execFileSync('claude', ['plugin', 'update', pluginId, '--scope', scope], {
+        encoding: 'utf-8',
+        stdio: 'inherit',
+    });
+}
+export function runUpdate(projectPath, installed, available, pluginIds, options = {}) {
+    const outdated = findOutdatedPlugins(installed, available, projectPath);
+    // Filter to specific plugins if provided
+    const toUpdate = pluginIds.length > 0
+        ? outdated.filter((p) => pluginIds.includes(p.id))
+        : outdated;
+    // Check if any specified plugins weren't found
+    if (pluginIds.length > 0) {
+        const outdatedIds = new Set(outdated.map((p) => p.id));
+        const installedIds = new Set(installed
+            .filter((p) => p.scope === 'local' && p.projectPath === projectPath)
+            .map((p) => p.id));
+        for (const id of pluginIds) {
+            if (!installedIds.has(id)) {
+                return {
+                    output: `Error: Plugin "${id}" not installed`,
+                    exitCode: 1,
+                    pluginsToUpdate: [],
+                };
+            }
+            if (!outdatedIds.has(id)) {
+                const plugin = installed.find((p) => p.id === id && p.scope === 'local' && p.projectPath === projectPath);
+                return {
+                    output: `✓ ${id} is already up-to-date (v${plugin?.version})`,
+                    exitCode: 0,
+                    pluginsToUpdate: [],
+                };
+            }
+        }
+    }
+    if (toUpdate.length === 0) {
+        return {
+            output: 'All plugins are up-to-date.',
+            exitCode: 0,
+            pluginsToUpdate: [],
+        };
+    }
+    if (options.dryRun) {
+        const lines = [`Would update ${toUpdate.length} plugin${toUpdate.length > 1 ? 's' : ''}:`];
+        for (const plugin of toUpdate) {
+            lines.push(`  ↑ ${plugin.id} v${plugin.installedVersion} → v${plugin.availableVersion}`);
+        }
+        return {
+            output: lines.join('\n'),
+            exitCode: 0,
+            pluginsToUpdate: [],
+        };
+    }
+    return {
+        output: `Updating ${toUpdate.length} outdated plugin${toUpdate.length > 1 ? 's' : ''}...`,
+        exitCode: 0,
+        pluginsToUpdate: toUpdate,
+    };
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "fitout",
+  "version": "0.1.0",
+  "description": "Context-aware plugin manager for Claude Code",
+  "type": "module",
+  "bin": {
+    "fitout": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "tsx src/cli.ts"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "plugins",
+    "cli"
+  ],
+  "author": "Josh Nichols",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/technicalpickles/fitout.git"
+  },
+  "homepage": "https://github.com/technicalpickles/fitout#readme",
+  "bugs": {
+    "url": "https://github.com/technicalpickles/fitout/issues"
+  },
+  "dependencies": {
+    "@pnpm/tabtab": "^0.5.4",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "smol-toml": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}