thufir 2.1.0

package/dist/analyze.d.ts

@@ -0,0 +1,28 @@
+export interface ThufirSettings {
+    version: string;
+    initialized: string;
+    last_realigned: string;
+    colleague_name: string;
+    user_name: string;
+    project_mode: 'single' | 'multi';
+    project_focus: 'code' | 'planning' | 'hybrid';
+    project_description: string;
+    traits: string[];
+    skillPackages?: string[];
+    skillTriggers?: string[];
+}
+export interface RepoAnalysis {
+    isGitRepo: boolean;
+    hasAgentsMd: boolean;
+    hasClaudeMd: boolean;
+    hasCursorRules: boolean;
+    hasDocsDir: boolean;
+    hasSkillsDir: boolean;
+    hasGitHubRemote: boolean;
+    gitHubRemoteUrl: string | null;
+    hasGhCli: boolean;
+    hasThufirMarker: boolean;
+    thufirSettings: ThufirSettings | null;
+    savedToken: string | null;
+}
+export declare function analyzeRepo(cwd: string): RepoAnalysis;

package/dist/analyze.js

@@ -0,0 +1,62 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+function commandExists(cmd) {
+    try {
+        execSync(`which ${cmd}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getGitRemote(cwd) {
+    try {
+        const output = execSync('git remote get-url origin', { encoding: 'utf-8', cwd, stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function analyzeRepo(cwd) {
+    let isGitRepo = false;
+    try {
+        execSync('git rev-parse --git-dir', { cwd, stdio: 'ignore' });
+        isGitRepo = true;
+    }
+    catch { /* not a git repo */ }
+    const remote = isGitRepo ? getGitRemote(cwd) : null;
+    const hasThufirMarker = existsSync(join(cwd, '.thufir'));
+    let thufirSettings = null;
+    if (hasThufirMarker) {
+        try {
+            thufirSettings = JSON.parse(readFileSync(join(cwd, '.thufir'), 'utf-8'));
+        }
+        catch { /* corrupt or unreadable */ }
+    }
+    let savedToken = null;
+    const localPath = join(cwd, '.thufir.local');
+    if (existsSync(localPath)) {
+        try {
+            const local = JSON.parse(readFileSync(localPath, 'utf-8'));
+            if (local.token)
+                savedToken = local.token;
+        }
+        catch { /* ignore */ }
+    }
+    return {
+        isGitRepo,
+        hasAgentsMd: existsSync(join(cwd, 'AGENTS.md')),
+        hasClaudeMd: existsSync(join(cwd, 'CLAUDE.md')),
+        hasCursorRules: existsSync(join(cwd, '.cursorrules')),
+        hasDocsDir: existsSync(join(cwd, 'docs')),
+        hasSkillsDir: existsSync(join(cwd, '.claude', 'skills')),
+        hasGitHubRemote: remote !== null,
+        gitHubRemoteUrl: remote,
+        hasGhCli: commandExists('gh'),
+        hasThufirMarker,
+        thufirSettings,
+        savedToken,
+    };
+}

package/dist/api.d.ts

@@ -0,0 +1,15 @@
+interface ValidateResponse {
+    valid: boolean;
+    owner?: string;
+    projects_remaining?: number;
+    expires?: string;
+    error?: string;
+}
+export declare function validateToken(token: string): Promise<ValidateResponse>;
+export declare function reportUsage(token: string, repoId: string): Promise<void>;
+export declare function checkVersion(currentVersion: string): Promise<{
+    updateAvailable: boolean;
+    latest: string;
+    changelog: string;
+}>;
+export {};

package/dist/api.js

@@ -0,0 +1,30 @@
+const API_BASE = 'https://thufir-api.krisztian-596.workers.dev';
+export async function validateToken(token) {
+    const res = await fetch(`${API_BASE}/validate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token }),
+    });
+    return res.json();
+}
+export async function reportUsage(token, repoId) {
+    await fetch(`${API_BASE}/use`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token, repo_id: repoId }),
+    });
+}
+export async function checkVersion(currentVersion) {
+    try {
+        const res = await fetch(`${API_BASE}/version`);
+        const data = await res.json();
+        return {
+            updateAvailable: data.latest !== currentVersion,
+            latest: data.latest,
+            changelog: data.changelog,
+        };
+    }
+    catch {
+        return { updateAvailable: false, latest: currentVersion, changelog: '' };
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function runInit(): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,183 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { execSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { showVersionCheck } from '../version-check.js';
+import { analyzeRepo } from '../analyze.js';
+import { runPrompts, runRealignPrompts, runMergePrompts } from '../prompts.js';
+import { printCompleteScreen, printGetStarted, printCommitScreen } from '../ui/ascii.js';
+import { scaffold, createInitialCommit, setupGitHub, backupAgentFiles, generateMergePrompt } from '../scaffold.js';
+import { reportUsage } from '../api.js';
+function commandExists(cmd) {
+    try {
+        execSync(`which ${cmd}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runInit() {
+    const cwd = process.cwd();
+    // Version check (non-blocking)
+    await showVersionCheck();
+    // Analyze repo first
+    const analysis = analyzeRepo(cwd);
+    // --- Mode B: Realign (.thufir exists) ---
+    if (analysis.hasThufirMarker && analysis.thufirSettings) {
+        const result = await runRealignPrompts(analysis.thufirSettings, analysis.savedToken);
+        if (!result) {
+            console.log(pc.dim('  Cancelled.'));
+            process.exit(0);
+        }
+        // Commit screen
+        printCommitScreen(result.answers.colleagueName, result.action === 'reconfigure' ? 'reconfigure' : 'realign');
+        const commitChoice = await p.select({
+            message: pc.yellow(pc.bold('Execute the command?')),
+            options: [
+                { value: 'execute', label: '⚔  Execute', hint: 'commit to this action' },
+                { value: 'abort', label: '↩  Abort', hint: 'return without changes' },
+            ],
+        });
+        if (p.isCancel(commitChoice) || commitChoice === 'abort') {
+            console.log(pc.dim('  No changes made.'));
+            process.exit(0);
+        }
+        // Scaffold in realign mode
+        const s = p.spinner();
+        s.start(`Realigning ${result.answers.colleagueName}...`);
+        // Preserve original initialized date
+        result.answers._originalInitialized = analysis.thufirSettings.initialized;
+        const scaffoldResult = scaffold(cwd, result.answers, analysis, true);
+        s.stop(`${result.answers.colleagueName} realigned.`);
+        // Report usage (realign doesn't count as new project use)
+        const repoId = analysis.gitHubRemoteUrl || cwd;
+        await reportUsage(result.answers.token, repoId).catch(() => { });
+        // Complete screen + summary
+        printCompleteScreen(result.answers.colleagueName);
+        for (const file of scaffoldResult.filesCreated) {
+            console.log(`  ${pc.green('✓')} Updated ${file}`);
+        }
+        console.log();
+        console.log(pc.dim(`  Review changes with ${pc.bold('git diff')}, then commit when ready.`));
+        console.log();
+        printGetStarted(result.answers.colleagueName);
+        return;
+    }
+    // --- Mode C: Merge (agent files exist but no .thufir) ---
+    if ((analysis.hasAgentsMd || analysis.hasClaudeMd || analysis.hasCursorRules) && !analysis.hasThufirMarker) {
+        const mergeAnswers = await runMergePrompts(analysis);
+        if (!mergeAnswers) {
+            console.log(pc.dim('  Cancelled.'));
+            process.exit(0);
+        }
+        const s = p.spinner();
+        // Step 1: Backup
+        s.start('Backing up existing agent files...');
+        const backedUp = backupAgentFiles(cwd);
+        s.stop(`Backed up ${backedUp.length} files to .thufir-backup/`);
+        // Step 2: Scaffold (overwrites agent files with Thufir versions)
+        s.start(`Setting up ${mergeAnswers.colleagueName}...`);
+        const scaffoldResult = scaffold(cwd, mergeAnswers, analysis);
+        s.stop('Thufir files written.');
+        // Step 3: Generate merge prompt
+        s.start('Generating merge plan...');
+        const mergePrompt = generateMergePrompt(cwd, mergeAnswers, backedUp);
+        const promptPath = join(cwd, '.thufir-backup', 'merge-prompt.md');
+        writeFileSync(promptPath, mergePrompt, 'utf-8');
+        s.stop('Merge plan ready.');
+        // Step 4: Detect and run local agent
+        const hasClaude = commandExists('claude');
+        const hasCursor = commandExists('cursor');
+        // Report usage
+        const repoId = analysis.gitHubRemoteUrl || cwd;
+        await reportUsage(mergeAnswers.token, repoId).catch(() => { });
+        printCompleteScreen(mergeAnswers.colleagueName);
+        for (const file of backedUp) {
+            console.log(`  ${pc.yellow('↗')} Backed up ${file}`);
+        }
+        for (const file of scaffoldResult.filesCreated) {
+            console.log(`  ${pc.green('✓')} Created ${file}`);
+        }
+        console.log(`  ${pc.blue('📋')} Merge plan: .thufir-backup/merge-prompt.md`);
+        console.log();
+        if (hasClaude) {
+            const runAgent = await p.confirm({
+                message: 'Claude Code CLI detected. Run the merge agent now?',
+            });
+            if (!p.isCancel(runAgent) && runAgent) {
+                p.log.step('Running merge agent via Claude Code...');
+                try {
+                    execSync(`claude -p "$(cat .thufir-backup/merge-prompt.md)"`, {
+                        cwd,
+                        stdio: 'inherit',
+                        timeout: 300000, // 5 min timeout
+                    });
+                    p.log.success('Merge agent completed.');
+                }
+                catch {
+                    p.log.warn('Merge agent exited. You can re-run manually:');
+                    console.log(pc.dim(`  claude -p "$(cat .thufir-backup/merge-prompt.md)"`));
+                }
+            }
+            else {
+                p.log.info('Run the merge agent manually when ready:');
+                console.log(pc.dim(`  claude -p "$(cat .thufir-backup/merge-prompt.md)"`));
+            }
+        }
+        else if (hasCursor) {
+            p.log.info('Open this project in Cursor and paste the contents of:');
+            console.log(pc.dim(`  .thufir-backup/merge-prompt.md`));
+        }
+        else {
+            p.log.info('Open this project in Claude Code or Cursor and paste the contents of:');
+            console.log(pc.dim(`  .thufir-backup/merge-prompt.md`));
+        }
+        printGetStarted(mergeAnswers.colleagueName);
+        return;
+    }
+    // --- Mode A: Fresh install ---
+    const answers = await runPrompts(analysis, analysis.savedToken);
+    if (!answers) {
+        console.log(pc.dim('  Cancelled.'));
+        process.exit(0);
+    }
+    // Commit screen
+    printCommitScreen(answers.colleagueName, 'install');
+    const commitChoice = await p.select({
+        message: pc.yellow(pc.bold('Execute the command?')),
+        options: [
+            { value: 'execute', label: '⚔  Execute', hint: 'commit to this action' },
+            { value: 'abort', label: '↩  Abort', hint: 'return without changes' },
+        ],
+    });
+    if (p.isCancel(commitChoice) || commitChoice === 'abort') {
+        console.log(pc.dim('  No changes made.'));
+        process.exit(0);
+    }
+    // Scaffold
+    const s = p.spinner();
+    s.start(`Setting up ${answers.colleagueName}...`);
+    const result = scaffold(cwd, answers, analysis);
+    createInitialCommit(cwd, result.filesCreated, answers.colleagueName);
+    s.stop(`${answers.colleagueName} is ready.`);
+    // GitHub setup
+    if (answers.setupGitHub !== 'skip' && analysis.hasGhCli) {
+        setupGitHub(cwd, answers.setupGitHub, answers.repoName);
+    }
+    // Report usage to API (after files written — safe)
+    const repoId = analysis.gitHubRemoteUrl || cwd;
+    await reportUsage(answers.token, repoId).catch(() => { });
+    // Summary
+    printCompleteScreen(answers.colleagueName);
+    if (result.gitInitialized) {
+        console.log(`  ${pc.green('✓')} Initialized git repository`);
+    }
+    for (const file of result.filesCreated) {
+        console.log(`  ${pc.green('✓')} Created ${file}`);
+    }
+    console.log(`  ${pc.green('✓')} Created initial commit`);
+    console.log();
+    printGetStarted(answers.colleagueName);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runInit } from './commands/init.js';
+const command = process.argv[2];
+if (command === 'init') {
+    runInit();
+}
+else {
+    console.log('Usage: thufir init');
+    process.exit(1);
+}

package/dist/prompts.d.ts

@@ -0,0 +1,22 @@
+import { type RepoAnalysis, type ThufirSettings } from './analyze.js';
+export interface InitAnswers {
+    token: string;
+    userName: string;
+    colleagueName: string;
+    projectMode: 'single' | 'multi';
+    projectDescription: string;
+    projectFocus: 'code' | 'planning' | 'hybrid';
+    traits: string[];
+    skillPackages: string[];
+    skillTriggers: string[];
+    setupGitHub: 'create' | 'connect' | 'skip';
+    repoName: string;
+}
+export declare function runPrompts(analysis: RepoAnalysis, savedToken?: string | null): Promise<InitAnswers | null>;
+export declare function runMergePrompts(analysis: RepoAnalysis): Promise<InitAnswers | null>;
+export type RealignAction = 'realign' | 'reconfigure' | 'cancel';
+export interface RealignResult {
+    action: RealignAction;
+    answers: InitAnswers;
+}
+export declare function runRealignPrompts(settings: ThufirSettings, savedToken: string | null): Promise<RealignResult | null>;