thufir 2.1.0

package/dist/prompts.js

@@ -0,0 +1,547 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { execSync } from 'node:child_process';
+import { basename } from 'node:path';
+import { validateToken } from './api.js';
+import { printBanner, printStepHeader, printRealignScreen, printMergeScreen, STEP_TITLES } from './ui/ascii.js';
+const TRAIT_OPTIONS = [
+    { value: 'consultant', label: 'Top Consultant', hint: 'MBB problem-solving, pyramid communication, Zelazny data viz. Your McKinsey associate.' },
+    { value: 'psychology', label: 'Human Psychology', hint: 'Parts (IFS), systemic thinking (Hellinger), compassion. Understands people.' },
+];
+const TRAIT_LABELS = {
+    'mentat-core': 'Mentat Discipline',
+    'consultant': 'Top Consultant',
+    'psychology': 'Human Psychology',
+};
+const SKILL_PACKAGE_OPTIONS = [
+    { value: 'superpowers', label: 'Superpowers', hint: 'Brainstorming, TDD, systematic debugging, code review, plans' },
+    { value: 'gstack', label: 'gstack (Garry Tan)', hint: 'Browser QA, code review, shipping, CEO/eng plan review' },
+];
+const SKILL_PACKAGE_LABELS = {
+    'superpowers': 'Superpowers',
+    'gstack': 'gstack (Garry Tan)',
+};
+const TRIGGER_OPTIONS = [
+    { value: 'brainstorming', label: '📋 Brainstorming', hint: 'requirements, creative work, problem solving' },
+    { value: 'plans', label: '📋 Implementation Plans', hint: 'break specs into step-by-step plans' },
+    { value: 'ceo-review', label: '📋 CEO/Product Review', hint: 'rethink requirements, find 10-star solution' },
+    { value: 'eng-review', label: '📋 Engineering Review', hint: 'lock architecture, map edge cases' },
+    { value: 'tdd', label: '🔧 Test-Driven Development', hint: 'write tests first, then implement' },
+    { value: 'code-review', label: '🔧 Code Review', hint: 'review before merging, verify feedback' },
+    { value: 'verification', label: '🔧 Verification', hint: 'run checks before claiming complete' },
+    { value: 'debugging', label: '🔧 Systematic Debugging', hint: 'scientific method for bugs' },
+    { value: 'browse', label: '🌐 Browser Automation', hint: 'test features in headless Chromium' },
+    { value: 'qa', label: '🌐 QA Testing', hint: 'systematic test → find → fix → verify' },
+    { value: 'design-review', label: '🌐 Design Audit', hint: '80-item visual/UX audit' },
+    { value: 'shipping', label: '🚀 Shipping', hint: 'tests, comments, push, PR' },
+    { value: 'parallel', label: '🚀 Parallel Agents', hint: 'dispatch subagents for independent tasks' },
+    { value: 'retro', label: '🚀 Retrospective', hint: 'commit history, work patterns' },
+];
+const ALL_TRIGGER_VALUES = TRIGGER_OPTIONS.map(t => t.value);
+async function promptAndValidateToken(savedToken) {
+    let tokenValue;
+    if (savedToken) {
+        tokenValue = savedToken;
+        p.log.info('Using saved token from .thufir.local');
+    }
+    else {
+        const token = await p.password({
+            message: 'Enter your access token',
+        });
+        if (p.isCancel(token))
+            return null;
+        tokenValue = token;
+    }
+    const s = p.spinner();
+    s.start('Validating token...');
+    const validation = await validateToken(tokenValue);
+    s.stop(validation.valid ? 'Token validated' : 'Token invalid');
+    if (!validation.valid) {
+        p.log.error(validation.error || 'Invalid token');
+        return null;
+    }
+    p.log.success(`${validation.projects_remaining} project${validation.projects_remaining === 1 ? '' : 's'} remaining, expires ${validation.expires?.split('T')[0]}`);
+    return tokenValue;
+}
+const TOTAL_STEPS = 7;
+export async function runPrompts(analysis, savedToken) {
+    const cwd = process.cwd();
+    let step = 1;
+    let token = '';
+    let userName = '';
+    let colleagueName = 'Thufir';
+    let projectMode = 'single';
+    let projectDescription = '';
+    let projectFocus = 'hybrid';
+    let traits = ['mentat-core', 'consultant', 'psychology'];
+    let skillPackages = [];
+    let skillTriggers = [];
+    let setupGitHub = 'skip';
+    let repoName = basename(cwd);
+    // Skip token step if we have a saved token
+    if (savedToken) {
+        const s = p.spinner();
+        printBanner();
+        s.start('Validating saved token...');
+        const validation = await validateToken(savedToken);
+        s.stop(validation.valid ? 'Token validated' : 'Token invalid');
+        if (validation.valid) {
+            token = savedToken;
+            step = 2;
+        }
+        else {
+            p.log.warn('Saved token is no longer valid. Please enter a new one.');
+        }
+    }
+    while (step <= TOTAL_STEPS) {
+        if (step === 1) {
+            printBanner();
+            const result = await promptAndValidateToken();
+            if (result === null)
+                return null;
+            token = result;
+            step = 2;
+            continue;
+        }
+        if (step === 2) {
+            printStepHeader(2, TOTAL_STEPS, STEP_TITLES[2]);
+            const nameResult = await p.text({
+                message: "What's your name?",
+                placeholder: 'Your name',
+                defaultValue: userName || undefined,
+                validate: (v) => !v || v.length === 0 ? 'Name is required' : undefined,
+            });
+            if (p.isCancel(nameResult)) {
+                step = 1;
+                continue;
+            }
+            userName = nameResult;
+            const colleagueResult = await p.text({
+                message: 'What should your AI colleague be called?',
+                placeholder: 'Thufir',
+                defaultValue: colleagueName,
+            });
+            if (p.isCancel(colleagueResult)) {
+                step = 1;
+                continue;
+            }
+            colleagueName = colleagueResult || 'Thufir';
+            step = 3;
+            continue;
+        }
+        if (step === 3) {
+            printStepHeader(3, TOTAL_STEPS, STEP_TITLES[3]);
+            const modeResult = await p.select({
+                message: 'What kind of project is this?',
+                options: [
+                    { value: 'single', label: 'Single project', hint: 'one repo, focused scope' },
+                    { value: 'multi', label: 'Multi-project orchestrator', hint: 'manages sub-projects (coming soon)' },
+                ],
+            });
+            if (p.isCancel(modeResult)) {
+                step = 2;
+                continue;
+            }
+            projectMode = modeResult;
+            if (projectMode === 'multi') {
+                p.log.warn('Multi-project mode templates are coming soon. Setting up single-project for now.');
+            }
+            const descResult = await p.text({
+                message: 'What is this project about?',
+                placeholder: 'A coaching business website with client portal',
+                defaultValue: projectDescription || undefined,
+                validate: (v) => !v || v.length === 0 ? 'Please describe your project' : undefined,
+            });
+            if (p.isCancel(descResult)) {
+                step = 2;
+                continue;
+            }
+            projectDescription = descResult;
+            const focusResult = await p.select({
+                message: 'Which best describes the focus?',
+                options: [
+                    { value: 'code', label: 'Mostly code', hint: 'building software, APIs, frontends' },
+                    { value: 'planning', label: 'Mostly planning', hint: 'business docs, research, strategy' },
+                    { value: 'hybrid', label: 'Both', hint: 'code AND business/project management' },
+                ],
+            });
+            if (p.isCancel(focusResult)) {
+                step = 2;
+                continue;
+            }
+            projectFocus = focusResult;
+            step = 4;
+            continue;
+        }
+        if (step === 4) {
+            printStepHeader(4, TOTAL_STEPS, STEP_TITLES[4]);
+            console.log(`  ${pc.green('✓')} ${pc.bold('Mentat Discipline')} ${pc.dim('(core — always installed)')}`);
+            console.log(pc.dim('    The brain. Learns, structures, remembers. Direct and precise.'));
+            console.log();
+            const traitsResult = await p.multiselect({
+                message: 'Additional personality traits:',
+                options: TRAIT_OPTIONS,
+                initialValues: traits.filter(t => t !== 'mentat-core'),
+                required: false,
+            });
+            if (p.isCancel(traitsResult)) {
+                step = 3;
+                continue;
+            }
+            traits = ['mentat-core', ...(traitsResult || [])];
+            // Confirm selection
+            const selected = traits.map(t => TRAIT_LABELS[t] || t).join(', ');
+            console.log();
+            console.log(pc.dim(`  Selected: ${selected}`));
+            const ok = await p.select({
+                message: 'Continue with these traits?',
+                options: [
+                    { value: 'yes', label: '✓ Continue', hint: 'proceed to next step' },
+                    { value: 'no', label: '← Re-select', hint: 'choose again' },
+                ],
+            });
+            if (p.isCancel(ok)) {
+                step = 3;
+                continue;
+            }
+            if (ok === 'no')
+                continue; // Re-run step 4
+            step = 5;
+            continue;
+        }
+        if (step === 5) {
+            printStepHeader(5, TOTAL_STEPS, STEP_TITLES[5]);
+            console.log(pc.yellow(`  ⚠ Skills install to ~/.claude/skills/ and will be`));
+            console.log(pc.yellow(`    available in ALL your Claude Code projects.`));
+            console.log();
+            const defaultSkills = skillPackages.length > 0 ? skillPackages : ['superpowers', 'gstack'];
+            const skillsResult = await p.multiselect({
+                message: 'Which skill packages should be available?',
+                options: SKILL_PACKAGE_OPTIONS,
+                initialValues: defaultSkills,
+                required: false,
+            });
+            if (p.isCancel(skillsResult)) {
+                step = 4;
+                continue;
+            }
+            skillPackages = skillsResult || [];
+            // Confirm
+            const selected = skillPackages.map(s => SKILL_PACKAGE_LABELS[s] || s).join(', ') || 'none';
+            console.log();
+            console.log(pc.dim(`  Selected: ${selected}`));
+            const ok = await p.select({
+                message: 'Continue with these packages?',
+                options: [
+                    { value: 'yes', label: '✓ Continue', hint: 'proceed to next step' },
+                    { value: 'no', label: '← Re-select', hint: 'choose again' },
+                ],
+            });
+            if (p.isCancel(ok)) {
+                step = 4;
+                continue;
+            }
+            if (ok === 'no')
+                continue; // Re-run step 5
+            // If no packages selected, skip trigger selection
+            if (skillPackages.length === 0) {
+                skillTriggers = [];
+                step = 7;
+            }
+            else {
+                step = 6;
+            }
+            continue;
+        }
+        if (step === 6) {
+            printStepHeader(6, TOTAL_STEPS, STEP_TITLES[6]);
+            console.log(pc.dim('  These determine when your colleague automatically invokes skills.'));
+            console.log(pc.dim('  All are ON by default — deselect any you don\'t want.'));
+            console.log();
+            const defaults = skillTriggers.length > 0 ? skillTriggers : ALL_TRIGGER_VALUES;
+            const triggersResult = await p.multiselect({
+                message: 'Active skill triggers:',
+                options: TRIGGER_OPTIONS,
+                initialValues: defaults,
+                required: false,
+            });
+            if (p.isCancel(triggersResult)) {
+                step = 5;
+                continue;
+            }
+            skillTriggers = triggersResult || [];
+            // Confirm
+            console.log();
+            console.log(pc.dim(`  ${skillTriggers.length} of ${ALL_TRIGGER_VALUES.length} triggers active`));
+            const ok = await p.select({
+                message: 'Continue with these triggers?',
+                options: [
+                    { value: 'yes', label: '✓ Continue', hint: 'proceed to review' },
+                    { value: 'no', label: '← Re-select', hint: 'choose again' },
+                ],
+            });
+            if (p.isCancel(ok)) {
+                step = 5;
+                continue;
+            }
+            if (ok === 'no')
+                continue; // Re-run step 6
+            step = 7;
+            continue;
+        }
+        if (step === 7) {
+            printStepHeader(7, TOTAL_STEPS, STEP_TITLES[7]);
+            // Show summary
+            console.log(pc.bold('  Review & Confirm'));
+            console.log();
+            console.log(`  Colleague: ${pc.yellow(pc.bold(colleagueName))}`);
+            console.log(`  User: ${pc.bold(userName)}`);
+            console.log(`  Project: ${pc.dim(projectDescription)}`);
+            console.log(`  Focus: ${pc.dim(projectFocus)}`);
+            console.log(`  Traits: ${pc.dim(traits.map(t => TRAIT_LABELS[t] || t).join(', ') || 'none')}`);
+            console.log(`  Skills: ${pc.dim(skillPackages.map(s => SKILL_PACKAGE_LABELS[s] || s).join(', ') || 'none')}`);
+            console.log(`  Active triggers: ${pc.dim(`${skillTriggers.length} of ${ALL_TRIGGER_VALUES.length}`)}`);
+            console.log();
+            // Repo analysis
+            console.log(pc.bold('  Repository'));
+            const checks = [
+                [analysis.isGitRepo, 'Git repo detected', 'No git repo (will initialize)'],
+                [analysis.hasAgentsMd, 'AGENTS.md found', 'No AGENTS.md'],
+                [analysis.hasClaudeMd, 'CLAUDE.md found', 'No CLAUDE.md'],
+                [analysis.hasCursorRules, '.cursorrules found', 'No .cursorrules'],
+                [analysis.hasGitHubRemote, `GitHub remote: ${analysis.gitHubRemoteUrl}`, 'GitHub remote: not configured'],
+                [analysis.hasGhCli, 'gh CLI: installed', 'gh CLI: not found'],
+            ];
+            for (const [found, yes, no] of checks) {
+                console.log(`  ${found ? pc.green('✓') : pc.dim('✗')} ${found ? yes : pc.dim(no)}`);
+            }
+            console.log();
+            // GitHub setup (only if no remote)
+            let repoName = basename(cwd);
+            if (!analysis.hasGitHubRemote) {
+                if (!analysis.hasGhCli) {
+                    p.log.warn(`gh CLI not found. Install it with: ${pc.bold('brew install gh')}`);
+                    p.log.info('Skipping GitHub setup for now.');
+                    setupGitHub = 'skip';
+                }
+                else {
+                    // Check if gh is authenticated
+                    let ghAuthed = false;
+                    try {
+                        execSync('gh auth status', { stdio: 'ignore' });
+                        ghAuthed = true;
+                    }
+                    catch { /* not logged in */ }
+                    if (!ghAuthed) {
+                        p.log.warn('GitHub CLI is installed but not logged in.');
+                        const loginChoice = await p.confirm({
+                            message: 'Would you like to log in to GitHub now?',
+                        });
+                        if (!p.isCancel(loginChoice) && loginChoice) {
+                            try {
+                                execSync('gh auth login', { stdio: 'inherit' });
+                                ghAuthed = true;
+                                p.log.success('Logged in to GitHub.');
+                            }
+                            catch {
+                                p.log.warn('GitHub login failed. Skipping GitHub setup.');
+                            }
+                        }
+                    }
+                    if (ghAuthed) {
+                        const ghChoice = await p.select({
+                            message: 'Set up a GitHub repository?',
+                            options: [
+                                { value: 'create', label: 'Yes, create a new private repo' },
+                                { value: 'connect', label: 'Yes, connect to an existing repo' },
+                                { value: 'skip', label: 'Skip for now' },
+                            ],
+                        });
+                        if (p.isCancel(ghChoice)) {
+                            step = skillPackages.length > 0 ? 6 : 5;
+                            continue;
+                        }
+                        setupGitHub = ghChoice;
+                        if (setupGitHub === 'create') {
+                            const nameResult = await p.text({
+                                message: 'Repository name:',
+                                placeholder: basename(cwd),
+                                defaultValue: basename(cwd),
+                            });
+                            if (p.isCancel(nameResult)) {
+                                step = skillPackages.length > 0 ? 6 : 5;
+                                continue;
+                            }
+                            repoName = nameResult || basename(cwd);
+                        }
+                    }
+                    else {
+                        setupGitHub = 'skip';
+                    }
+                }
+            }
+            const confirm = await p.select({
+                message: 'Ready to install?',
+                options: [
+                    { value: 'confirm', label: 'Install Thufir', hint: 'set up your AI colleague' },
+                    { value: 'back', label: 'Go back', hint: 'change settings' },
+                ],
+            });
+            if (p.isCancel(confirm) || confirm === 'back') {
+                step = skillPackages.length > 0 ? 6 : 5;
+                continue;
+            }
+            step = TOTAL_STEPS + 1; // Exit the loop
+            continue;
+        }
+    }
+    return {
+        token,
+        userName,
+        colleagueName,
+        projectMode,
+        projectDescription,
+        projectFocus,
+        traits,
+        skillPackages,
+        skillTriggers,
+        setupGitHub,
+        repoName,
+    };
+}
+export async function runMergePrompts(analysis) {
+    printMergeScreen();
+    p.log.info('This repo has existing agent files. Thufir will:');
+    console.log(pc.dim('  1. Back up your current agent files'));
+    console.log(pc.dim('  2. Set up Thufir conventions'));
+    console.log(pc.dim('  3. Merge your original intentions into the new structure'));
+    console.log(pc.dim('  4. Run a local agent to reorganize the repo'));
+    console.log();
+    const proceed = await p.confirm({
+        message: 'Would you like to proceed with merge?',
+    });
+    if (p.isCancel(proceed) || !proceed)
+        return null;
+    // Then run the normal prompts (token, name, traits, etc.)
+    return runPrompts(analysis);
+}
+export async function runRealignPrompts(settings, savedToken) {
+    printRealignScreen();
+    // Show current config
+    const traitLabels = (settings.traits || []).map(t => TRAIT_LABELS[t] || t).join(', ');
+    const skillLabels = (settings.skillPackages || []).map(s => SKILL_PACKAGE_LABELS[s] || s).join(', ');
+    p.log.info('Found existing Thufir configuration:');
+    console.log(`    Colleague: ${pc.bold(settings.colleague_name)}`);
+    console.log(`    User: ${pc.bold(settings.user_name)}`);
+    console.log(`    Focus: ${pc.bold(settings.project_focus)}`);
+    console.log(`    Traits: ${pc.bold(traitLabels || 'none')}`);
+    console.log(`    Skills: ${pc.bold(skillLabels || 'none')}`);
+    console.log(`    Last aligned: ${pc.bold(settings.last_realigned || settings.initialized)}`);
+    console.log();
+    // Ask what to do
+    const action = await p.select({
+        message: 'What would you like to do?',
+        options: [
+            { value: 'realign', label: 'Realign', hint: 'update to latest Thufir with current settings' },
+            { value: 'reconfigure', label: 'Reconfigure', hint: 'change personality traits and settings' },
+            { value: 'cancel', label: 'Cancel' },
+        ],
+    });
+    if (p.isCancel(action))
+        return null;
+    if (action === 'cancel')
+        return null;
+    // Validate token
+    const token = await promptAndValidateToken(savedToken);
+    if (!token)
+        return null;
+    if (action === 'realign') {
+        return {
+            action: 'realign',
+            answers: {
+                token,
+                userName: settings.user_name,
+                colleagueName: settings.colleague_name,
+                projectMode: settings.project_mode || 'single',
+                projectDescription: settings.project_description || '',
+                projectFocus: settings.project_focus || 'hybrid',
+                traits: settings.traits || [],
+                skillPackages: settings.skillPackages || [],
+                skillTriggers: settings.skillTriggers || [],
+                setupGitHub: 'skip',
+                repoName: '',
+            },
+        };
+    }
+    // Reconfigure — step through changeable settings
+    printStepHeader(1, 4, 'Reconfigure');
+    const colleagueName = await p.text({
+        message: 'What should your AI colleague be called?',
+        placeholder: settings.colleague_name,
+        defaultValue: settings.colleague_name,
+    });
+    if (p.isCancel(colleagueName))
+        return null;
+    printStepHeader(2, 4, 'Reconfigure');
+    const projectFocus = await p.select({
+        message: 'Which best describes the focus?',
+        options: [
+            { value: 'code', label: 'Mostly code', hint: 'building software, APIs, frontends' },
+            { value: 'planning', label: 'Mostly planning', hint: 'business docs, research, strategy' },
+            { value: 'hybrid', label: 'Both', hint: 'code AND business/project management' },
+        ],
+        initialValue: settings.project_focus || 'hybrid',
+    });
+    if (p.isCancel(projectFocus))
+        return null;
+    printStepHeader(3, 4, 'Reconfigure');
+    const traits = await p.multiselect({
+        message: 'Which thinking styles should your colleague use?\n  (space = toggle, enter = confirm selection)',
+        options: TRAIT_OPTIONS,
+        initialValues: settings.traits || ['thufir'],
+        required: false,
+    });
+    if (p.isCancel(traits))
+        return null;
+    const skillPackages = await p.multiselect({
+        message: 'Which skill packages should be available?\n  (space = toggle, enter = confirm selection)',
+        options: SKILL_PACKAGE_OPTIONS,
+        initialValues: settings.skillPackages || [],
+        required: false,
+    });
+    if (p.isCancel(skillPackages))
+        return null;
+    let skillTriggers = settings.skillTriggers || [];
+    if (skillPackages.length > 0) {
+        printStepHeader(4, 4, 'Reconfigure');
+        const defaults = skillTriggers.length > 0 ? skillTriggers : ALL_TRIGGER_VALUES;
+        const triggersResult = await p.multiselect({
+            message: 'Which skill triggers should be active?\n  (space = toggle, enter = confirm selection)',
+            options: TRIGGER_OPTIONS,
+            initialValues: defaults,
+            required: false,
+        });
+        if (p.isCancel(triggersResult))
+            return null;
+        skillTriggers = triggersResult || [];
+    }
+    else {
+        skillTriggers = [];
+    }
+    return {
+        action: 'reconfigure',
+        answers: {
+            token,
+            userName: settings.user_name,
+            colleagueName: colleagueName || settings.colleague_name,
+            projectMode: settings.project_mode || 'single',
+            projectDescription: settings.project_description || '',
+            projectFocus: projectFocus,
+            traits: traits || [],
+            skillPackages: skillPackages || [],
+            skillTriggers,
+            setupGitHub: 'skip',
+            repoName: '',
+        },
+    };
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,13 @@
+import type { InitAnswers } from './prompts.js';
+export interface ScaffoldResult {
+    filesCreated: string[];
+    gitInitialized: boolean;
+}
+export declare function scaffold(cwd: string, answers: InitAnswers, analysis: {
+    isGitRepo: boolean;
+    hasGitHubRemote: boolean;
+}, isRealign?: boolean): ScaffoldResult;
+export declare function backupAgentFiles(cwd: string): string[];
+export declare function generateMergePrompt(cwd: string, answers: InitAnswers, backedUpFiles: string[]): string;
+export declare function createInitialCommit(cwd: string, files: string[], colleagueName: string): void;
+export declare function setupGitHub(cwd: string, mode: 'create' | 'connect', repoName?: string): boolean;