@buffbirb/unclaude 1.0.0

package/dist/uninstall.js

@@ -0,0 +1,595 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useMemo } from 'react';
+import { Box, Text, useInput, useApp } from 'ink';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, rmSync, readdirSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { join } from 'path';
+import { HOME, AIRC, CLAUDE_SETTINGS, OPENCODE_CONFIG, HCLAUDE, HOPENCODE, AGENT_IDS, SCOPE_IDS, GIT_SETTING_IDS, FEATURE_ORDER, AGENT_LABELS, SCOPE_LABELS, GIT_SETTING_LABELS, FEATURE_LABELS, getFeatureItems, toggleSelection, removeGitignoreEntries, run, stream, commandExists, nvmShell, readJson, patchJson, HEADROOM_START_FUNC, removeSessionStartHook, AGENT_MD_HEADER, removeSectionByHeader, FEATURE_SCOPES, } from './common.js';
+// ── Detection ─────────────────────────────────────────────────────────────────
+function detectInstalled() {
+    const airc = existsSync(AIRC) ? readFileSync(AIRC, 'utf8') : '';
+    const globalSettings = readJson(CLAUDE_SETTINGS);
+    const opencodeConfig = readJson(OPENCODE_CONFIG);
+    const sel = {
+        agents: new Set(),
+        scopes: new Set(),
+        features: new Set(),
+        lspLanguages: new Set(),
+        gitSettings: new Set(['gitignore']),
+    };
+    if (commandExists('claude'))
+        sel.agents.add('claudeCode');
+    if (commandExists('opencode'))
+        sel.agents.add('openCode');
+    if (existsSync(HCLAUDE) || existsSync(HOPENCODE) || airc.includes('headroom_start')) {
+        sel.features.add('headroom');
+    }
+    if (airc.includes('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC')) {
+        sel.features.add('stopTelemetry');
+    }
+    const attrGlobal = globalSettings['attribution'];
+    if (attrGlobal?.['commit'] === '') {
+        sel.features.add('stopAttributionConfig');
+        sel.scopes.add('global');
+    }
+    if (existsSync('.claude/settings.json')) {
+        const pSettings = readJson('.claude/settings.json');
+        const attrProject = pSettings['attribution'];
+        if (attrProject?.['commit'] === '') {
+            sel.features.add('stopAttributionConfig');
+            sel.scopes.add('project');
+        }
+    }
+    if (existsSync('.claude/hooks/strip-commit-attribution.sh'))
+        sel.features.add('stripCommitAttribution');
+    if (existsSync('.github/workflows/strip-pr-attribution.yml'))
+        sel.features.add('stripPrAttribution');
+    if (existsSync('.claude/hooks/strip-claude-branch.sh'))
+        sel.features.add('renameClaudeBranch');
+    if (existsSync(join(HOME, '.config', 'git', 'hooks', 'commit-msg'))) {
+        sel.features.add('stopAttributionHook');
+        sel.scopes.add('global');
+    }
+    try {
+        const gitDir = execFileSync('git', ['rev-parse', '--git-dir'], { encoding: 'utf8' }).trim();
+        if (existsSync(join(gitDir, 'hooks', 'commit-msg'))) {
+            sel.features.add('stopAttributionHook');
+            sel.scopes.add('project');
+        }
+    }
+    catch { /* not in a git repo */ }
+    const envSettings = globalSettings['env'];
+    if (envSettings?.['ENABLE_LSP_TOOL'] === '1') {
+        sel.features.add('lsp');
+        if (commandExists('clangd'))
+            sel.lspLanguages.add('cpp');
+        sel.lspLanguages.add('swift');
+    }
+    if (opencodeConfig['lsp'] === true) {
+        sel.features.add('lsp');
+    }
+    if (commandExists('openspec')) {
+        sel.features.add('openspec');
+    }
+    const globalClaudeMd = existsSync(join(HOME, '.claude', 'CLAUDE.md')) ? readFileSync(join(HOME, '.claude', 'CLAUDE.md'), 'utf8') : '';
+    if (globalClaudeMd.includes(AGENT_MD_HEADER)) {
+        sel.features.add('agentMdFile');
+        sel.scopes.add('global');
+    }
+    if (existsSync('CLAUDE.md')) {
+        const projectClaudeMd = readFileSync('CLAUDE.md', 'utf8');
+        if (projectClaudeMd.includes(AGENT_MD_HEADER)) {
+            sel.features.add('agentMdFile');
+            sel.scopes.add('project');
+        }
+    }
+    return sel;
+}
+// ── Uninstall functions ───────────────────────────────────────────────────────
+async function removeExecutable(filePath, onLine) {
+    if (!existsSync(filePath))
+        return;
+    try {
+        unlinkSync(filePath);
+    }
+    catch {
+        onLine(`sudo required to remove ${filePath}`);
+        try {
+            // -n = non-interactive: fail immediately if password needed (avoids TUI hang)
+            await run('sudo', ['-n', 'rm', filePath]);
+        }
+        catch {
+            onLine(`Could not remove ${filePath} — run manually: sudo rm ${filePath}`);
+            return;
+        }
+    }
+    onLine(`${filePath} removed`);
+}
+async function uninstallHeadroom(onLine) {
+    try {
+        const pids = await run('lsof', ['-ti:8787']);
+        for (const pid of pids.split('\n').filter(Boolean)) {
+            await run('kill', [pid]);
+        }
+        onLine('Headroom proxy stopped');
+    }
+    catch { /* not running */ }
+    await removeExecutable(HCLAUDE, onLine);
+    await removeExecutable(HOPENCODE, onLine);
+    if (existsSync(AIRC)) {
+        const content = readFileSync(AIRC, 'utf8');
+        const cleaned = content.replace(HEADROOM_START_FUNC, '');
+        if (cleaned !== content) {
+            writeFileSync(AIRC, cleaned);
+            onLine('headroom_start removed from ~/.airc');
+        }
+    }
+    if (commandExists('uv')) {
+        try {
+            await stream('uv', ['tool', 'uninstall', 'headroom-ai'], onLine);
+        }
+        catch {
+            onLine('Warning: headroom-ai not found in uv tools');
+        }
+    }
+}
+async function uninstallStopTelemetry(onLine) {
+    if (!existsSync(AIRC)) {
+        onLine('~/.airc not found');
+        return;
+    }
+    const lines = readFileSync(AIRC, 'utf8').split('\n');
+    const cleaned = lines.filter(l => !l.includes('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC'));
+    if (cleaned.length !== lines.length) {
+        writeFileSync(AIRC, cleaned.join('\n'));
+        onLine('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC removed from ~/.airc');
+    }
+    else {
+        onLine('CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC not found in ~/.airc');
+    }
+}
+async function uninstallStopAttributionConfig(scopes, onLine) {
+    if (scopes.has('global')) {
+        patchJson(CLAUDE_SETTINGS, d => { delete d['attribution']; });
+        onLine('attribution removed from ~/.claude/settings.json');
+    }
+    if (scopes.has('project') && existsSync('.claude/settings.json')) {
+        patchJson('.claude/settings.json', d => { delete d['attribution']; });
+        onLine('attribution removed from .claude/settings.json');
+    }
+}
+async function uninstallStopAttributionHook(onLine) {
+    try {
+        const gitDir = await run('git', ['rev-parse', '--git-dir']);
+        const hookPath = join(gitDir, 'hooks', 'commit-msg');
+        if (existsSync(hookPath)) {
+            unlinkSync(hookPath);
+            onLine('Project commit-msg hook removed');
+        }
+    }
+    catch {
+        onLine('Not in a git repo — skipping project hook removal');
+    }
+}
+async function uninstallStripCommitAttribution(onLine) {
+    const hookPath = '.claude/hooks/strip-commit-attribution.sh';
+    if (existsSync(hookPath)) {
+        unlinkSync(hookPath);
+        onLine(`${hookPath} removed`);
+    }
+    else {
+        onLine(`${hookPath} not found`);
+    }
+    if (existsSync('.claude/settings.json')) {
+        removeSessionStartHook('.claude/settings.json', 'bash .claude/hooks/strip-commit-attribution.sh');
+        onLine('SessionStart hook removed from .claude/settings.json');
+    }
+    try {
+        const gitDir = await run('git', ['rev-parse', '--git-dir']);
+        const cmHook = join(gitDir, 'hooks', 'commit-msg');
+        if (existsSync(cmHook)) {
+            unlinkSync(cmHook);
+            onLine('commit-msg hook removed from .git/hooks');
+        }
+    }
+    catch { /* not in a git repo */ }
+}
+async function uninstallStripPrAttribution(onLine) {
+    const wfPath = '.github/workflows/strip-pr-attribution.yml';
+    if (existsSync(wfPath)) {
+        unlinkSync(wfPath);
+        onLine(`${wfPath} removed`);
+    }
+    else {
+        onLine(`${wfPath} not found`);
+    }
+}
+async function uninstallRenameClaudeBranch(onLine) {
+    const hookPath = '.claude/hooks/strip-claude-branch.sh';
+    if (existsSync(hookPath)) {
+        unlinkSync(hookPath);
+        onLine(`${hookPath} removed`);
+    }
+    else {
+        onLine(`${hookPath} not found`);
+    }
+    if (existsSync('.claude/settings.json')) {
+        removeSessionStartHook('.claude/settings.json', 'bash .claude/hooks/strip-claude-branch.sh');
+        onLine('SessionStart hook removed from .claude/settings.json');
+    }
+}
+async function uninstallAgentMdFile(scopes, agents, onLine) {
+    if (agents.has('claudeCode')) {
+        if (scopes.has('global')) {
+            const removed = removeSectionByHeader(join(HOME, '.claude', 'CLAUDE.md'), AGENT_MD_HEADER);
+            onLine(removed ? 'CLAUDE.md cleaned (~/.claude/CLAUDE.md)' : 'CLAUDE.md not found (~/.claude/CLAUDE.md)');
+        }
+        if (scopes.has('project')) {
+            const removed = removeSectionByHeader('CLAUDE.md', AGENT_MD_HEADER);
+            onLine(removed ? 'CLAUDE.md cleaned (project)' : 'CLAUDE.md not found (project)');
+        }
+    }
+    if (agents.has('openCode')) {
+        if (scopes.has('global')) {
+            const removed = removeSectionByHeader(join(HOME, '.config', 'opencode', 'AGENTS.md'), AGENT_MD_HEADER);
+            onLine(removed ? 'AGENTS.md cleaned (~/.config/opencode/AGENTS.md)' : 'AGENTS.md not found (~/.config/opencode/AGENTS.md)');
+        }
+        if (scopes.has('project')) {
+            const removed = removeSectionByHeader('AGENTS.md', AGENT_MD_HEADER);
+            onLine(removed ? 'AGENTS.md cleaned (project)' : 'AGENTS.md not found (project)');
+        }
+    }
+}
+async function uninstallLsp(langs, agents, onLine) {
+    if (agents.has('claudeCode')) {
+        patchJson(CLAUDE_SETTINGS, d => {
+            const env = d['env'];
+            if (env)
+                delete env['ENABLE_LSP_TOOL'];
+        });
+        onLine('ENABLE_LSP_TOOL removed from ~/.claude/settings.json');
+        for (const lang of langs) {
+            const plugin = lang === 'cpp' ? 'clangd-lsp' : 'swift-lsp';
+            onLine(`Removing ${plugin}...`);
+            try {
+                await stream('claude', ['plugin', 'remove', plugin], onLine);
+                onLine(`${plugin} removed`);
+            }
+            catch {
+                onLine(`Warning: ${plugin} removal failed — remove manually`);
+            }
+        }
+        if (langs.has('cpp') && existsSync(AIRC)) {
+            const lines = readFileSync(AIRC, 'utf8').split('\n');
+            const cleaned = lines.filter(l => !(l.includes('export PATH=') && l.includes('llvm')));
+            if (cleaned.length !== lines.length) {
+                writeFileSync(AIRC, cleaned.join('\n'));
+                onLine('llvm PATH removed from ~/.airc');
+            }
+        }
+    }
+    if (agents.has('openCode')) {
+        patchJson(OPENCODE_CONFIG, d => { delete d['lsp']; });
+        onLine('LSP disabled in OpenCode config');
+    }
+}
+async function uninstallOpenspec(scopes, onLine) {
+    if (scopes.has('project')) {
+        for (const dir of ['openspec', '.claude/commands/opsx']) {
+            if (existsSync(dir)) {
+                rmSync(dir, { recursive: true, force: true });
+                onLine(`${dir}/ removed`);
+            }
+        }
+        const skillsDir = '.claude/skills';
+        if (existsSync(skillsDir)) {
+            for (const entry of readdirSync(skillsDir)) {
+                if (entry.startsWith('openspec-')) {
+                    rmSync(join(skillsDir, entry), { recursive: true, force: true });
+                    onLine(`.claude/skills/${entry} removed`);
+                }
+            }
+        }
+    }
+    if (scopes.has('global')) {
+        onLine('Uninstalling @fission-ai/openspec...');
+        const npmUninstallFlags = '--prefer-offline --no-audit --no-fund';
+        try {
+            await nvmShell(`NO_UPDATE_NOTIFIER=1 npm uninstall -g ${npmUninstallFlags} @fission-ai/openspec`, onLine);
+            onLine('@fission-ai/openspec uninstalled');
+        }
+        catch {
+            if (commandExists('npm')) {
+                await stream('npm', ['uninstall', '-g', '--prefer-offline', '--no-audit', '--no-fund', '@fission-ai/openspec'], onLine, { env: { ...process.env, NO_UPDATE_NOTIFIER: '1' } });
+                onLine('@fission-ai/openspec uninstalled');
+            }
+            else {
+                throw new Error('npm not found — uninstall @fission-ai/openspec manually');
+            }
+        }
+    }
+}
+// ── Orchestrator ──────────────────────────────────────────────────────────────
+export async function runUninstall(selection, updateStep) {
+    const { features, scopes, agents, lspLanguages } = selection;
+    const scopeOk = (feat) => scopes.size === 0 || FEATURE_SCOPES[feat].some(s => scopes.has(s));
+    const tasks = [];
+    if (features.has('headroom') && scopeOk('headroom'))
+        tasks.push(['headroom', () => uninstallHeadroom(l => updateStep('headroom', { line: l }))]);
+    if (features.has('stopTelemetry') && scopeOk('stopTelemetry'))
+        tasks.push(['stopTelemetry', () => uninstallStopTelemetry(l => updateStep('stopTelemetry', { line: l }))]);
+    if (features.has('stopAttributionConfig') && scopeOk('stopAttributionConfig'))
+        tasks.push(['stopAttributionConfig', () => uninstallStopAttributionConfig(scopes, l => updateStep('stopAttributionConfig', { line: l }))]);
+    if (features.has('stopAttributionHook') && scopeOk('stopAttributionHook'))
+        tasks.push(['stopAttributionHook', () => uninstallStopAttributionHook(l => updateStep('stopAttributionHook', { line: l }))]);
+    if (features.has('stripCommitAttribution') && scopeOk('stripCommitAttribution'))
+        tasks.push(['stripCommitAttribution', () => uninstallStripCommitAttribution(l => updateStep('stripCommitAttribution', { line: l }))]);
+    if (features.has('stripPrAttribution') && scopeOk('stripPrAttribution'))
+        tasks.push(['stripPrAttribution', () => uninstallStripPrAttribution(l => updateStep('stripPrAttribution', { line: l }))]);
+    if (features.has('renameClaudeBranch') && scopeOk('renameClaudeBranch'))
+        tasks.push(['renameClaudeBranch', () => uninstallRenameClaudeBranch(l => updateStep('renameClaudeBranch', { line: l }))]);
+    if (features.has('agentMdFile') && scopeOk('agentMdFile'))
+        tasks.push(['agentMdFile', () => uninstallAgentMdFile(scopes, agents, l => updateStep('agentMdFile', { line: l }))]);
+    if (features.has('lsp') && scopeOk('lsp'))
+        tasks.push(['lsp', () => uninstallLsp(lspLanguages, agents, l => updateStep('lsp', { line: l }))]);
+    if (features.has('openspec') && scopeOk('openspec'))
+        tasks.push(['openspec', () => uninstallOpenspec(scopes, l => updateStep('openspec', { line: l }))]);
+    for (const [id, fn] of tasks) {
+        updateStep(id, { status: 'running' });
+        try {
+            await fn();
+            updateStep(id, { status: 'done' });
+        }
+        catch (e) {
+            updateStep(id, { status: 'error', line: String(e) });
+        }
+    }
+}
+function buildSteps(sel) {
+    const steps = [];
+    for (const id of FEATURE_ORDER) {
+        if (!sel.features.has(id))
+            continue;
+        if (sel.scopes.size > 0 && !FEATURE_SCOPES[id].some(s => sel.scopes.has(s)))
+            continue;
+        steps.push({ id, label: FEATURE_LABELS[id], status: 'pending', lines: [] });
+    }
+    return steps;
+}
+function validate(sel) {
+    if (sel.features.size === 0)
+        return 'Nothing selected to uninstall';
+    const needsScope = ['stopAttributionConfig', 'stopAttributionHook', 'agentMdFile'];
+    const hasScoped = needsScope.some(f => sel.features.has(f));
+    if (hasScoped && sel.scopes.size === 0)
+        return 'Attribution features require a scope — check Global or Project';
+    return null;
+}
+// ── UI components ─────────────────────────────────────────────────────────────
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function useSpinner() {
+    const [i, setI] = useState(0);
+    useEffect(() => {
+        const t = setInterval(() => setI(n => (n + 1) % SPINNER.length), 80);
+        return () => clearInterval(t);
+    }, []);
+    return SPINNER[i];
+}
+const StatusIcon = ({ status }) => {
+    const spin = useSpinner();
+    const [icon, color] = (status === 'done' ? ['✓', 'green'] :
+        status === 'error' ? ['✗', 'red'] :
+            status === 'running' ? [spin, 'yellow'] :
+                status === 'skipped' ? ['-', 'gray'] :
+                    ['○', 'gray']);
+    return _jsx(Text, { color: color, children: icon });
+};
+const Checkbox = ({ state, label, focused, indent }) => (_jsxs(Box, { children: [_jsx(Text, { children: focused ? '▸ ' : '  ' }), _jsx(Box, { marginLeft: indent ? 4 : 0, children: _jsxs(Text, { color: focused ? 'yellow' : undefined, children: ["[", state === 'checked' ? '*' : state === 'partial' ? '+' : ' ', "] ", label] }) })] }));
+const PanelBox = ({ title, num, active, items, cursor, isChecked }) => (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { bold: true, color: active ? 'yellow' : 'white', children: [num, " ", title] }), items.map((item, i) => (_jsx(Checkbox, { state: isChecked(item), label: item.label, focused: active && cursor === i, indent: item.indent }, item.id)))] }));
+// ── SelectScreen ──────────────────────────────────────────────────────────────
+const SelectScreen = ({ initialSel, onConfirm }) => {
+    const { exit } = useApp();
+    const [panel, setPanel] = useState('features');
+    const [cursors, setCursors] = useState({ agents: 0, scope: 0, features: 0, gitSettings: 0 });
+    const [sel, setSel] = useState(initialSel);
+    const [warning, setWarning] = useState('');
+    const featureItems = useMemo(() => getFeatureItems(sel.agents, sel.scopes), [sel.agents, sel.scopes]);
+    useEffect(() => {
+        setCursors(c => ({
+            ...c,
+            features: Math.min(c.features, Math.max(0, featureItems.length - 1)),
+        }));
+    }, [featureItems.length]);
+    const panelSize = useCallback((p) => {
+        if (p === 'agents')
+            return AGENT_IDS.length;
+        if (p === 'scope')
+            return SCOPE_IDS.length;
+        if (p === 'gitSettings')
+            return GIT_SETTING_IDS.length;
+        return featureItems.length;
+    }, [featureItems.length]);
+    useInput((input, key) => {
+        if (input === 'q') {
+            exit();
+            return;
+        }
+        if (input === '1') {
+            setPanel('agents');
+            setCursors(c => ({ ...c, agents: 0 }));
+            return;
+        }
+        if (input === '2') {
+            setPanel('scope');
+            setCursors(c => ({ ...c, scope: 0 }));
+            return;
+        }
+        if (input === '3') {
+            setPanel('features');
+            setCursors(c => ({ ...c, features: 0 }));
+            return;
+        }
+        if (input === '4') {
+            setPanel('gitSettings');
+            setCursors(c => ({ ...c, gitSettings: 0 }));
+            return;
+        }
+        const PANEL_ORDER = ['agents', 'scope', 'features', 'gitSettings'];
+        if (key.upArrow) {
+            const currentCursor = cursors[panel];
+            const currentSize = panelSize(panel);
+            if (currentCursor > 0) {
+                setCursors(c => ({ ...c, [panel]: currentCursor - 1 }));
+            }
+            else {
+                const idx = PANEL_ORDER.indexOf(panel);
+                const prevPanel = PANEL_ORDER[idx === 0 ? PANEL_ORDER.length - 1 : idx - 1];
+                const prevSize = prevPanel === 'agents' ? AGENT_IDS.length :
+                    prevPanel === 'scope' ? SCOPE_IDS.length :
+                        featureItems.length;
+                setPanel(prevPanel);
+                setCursors(c => ({ ...c, [prevPanel]: prevSize - 1 }));
+            }
+            return;
+        }
+        if (key.downArrow) {
+            const currentCursor = cursors[panel];
+            const currentSize = panelSize(panel);
+            if (currentCursor < currentSize - 1) {
+                setCursors(c => ({ ...c, [panel]: currentCursor + 1 }));
+            }
+            else {
+                const idx = PANEL_ORDER.indexOf(panel);
+                const nextPanel = PANEL_ORDER[idx === PANEL_ORDER.length - 1 ? 0 : idx + 1];
+                setPanel(nextPanel);
+                setCursors(c => ({ ...c, [nextPanel]: 0 }));
+            }
+            return;
+        }
+        if (input === ' ') {
+            setSel(s => toggleSelection(panel, cursors[panel], s, featureItems));
+            setWarning('');
+            return;
+        }
+        if (key.return) {
+            const err = validate(sel);
+            if (err) {
+                setWarning(err);
+                return;
+            }
+            onConfirm(sel);
+        }
+    });
+    const agentItems = AGENT_IDS.map(id => ({ id, label: AGENT_LABELS[id], indent: false }));
+    const scopeItems = SCOPE_IDS.map(id => ({ id, label: SCOPE_LABELS[id], indent: false }));
+    const gitSettingItems = GIT_SETTING_IDS.map(id => ({ id, label: GIT_SETTING_LABELS[id], indent: false }));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Select what to uninstall" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(PanelBox, { num: "1", title: "Agents", active: panel === 'agents', items: agentItems, cursor: cursors.agents, isChecked: item => sel.agents.has(item.id) ? 'checked' : 'unchecked' }), _jsx(PanelBox, { num: "2", title: "Scope", active: panel === 'scope', items: scopeItems, cursor: cursors.scope, isChecked: item => sel.scopes.has(item.id) ? 'checked' : 'unchecked' }), _jsx(PanelBox, { num: "3", title: "Features", active: panel === 'features', items: featureItems, cursor: cursors.features, isChecked: item => {
+                            if (item.id === 'lsp.cpp')
+                                return sel.lspLanguages.has('cpp') ? 'checked' : 'unchecked';
+                            if (item.id === 'lsp.swift')
+                                return sel.lspLanguages.has('swift') ? 'checked' : 'unchecked';
+                            if (item.id === 'lsp') {
+                                const hasCpp = sel.lspLanguages.has('cpp');
+                                const hasSwift = sel.lspLanguages.has('swift');
+                                if (hasCpp && hasSwift)
+                                    return 'checked';
+                                if (hasCpp || hasSwift)
+                                    return 'partial';
+                                return 'unchecked';
+                            }
+                            if (item.id === 'stopAttribution.hook')
+                                return sel.features.has('stopAttributionHook') ? 'checked' : 'unchecked';
+                            if (item.id === 'stopAttribution.config')
+                                return sel.features.has('stopAttributionConfig') ? 'checked' : 'unchecked';
+                            if (item.id === 'stopAttribution.stripCommit')
+                                return sel.features.has('stripCommitAttribution') ? 'checked' : 'unchecked';
+                            if (item.id === 'stopAttribution.stripPr')
+                                return sel.features.has('stripPrAttribution') ? 'checked' : 'unchecked';
+                            if (item.id === 'stopAttribution.renameBranch')
+                                return sel.features.has('renameClaudeBranch') ? 'checked' : 'unchecked';
+                            if (item.id === 'stopAttribution.mdFile')
+                                return sel.features.has('agentMdFile') ? 'checked' : 'unchecked';
+                            if (item.id === 'stopAttribution') {
+                                const subs = [];
+                                if (featureItems.some(fi => fi.id === 'stopAttribution.hook'))
+                                    subs.push('stopAttributionHook');
+                                if (featureItems.some(fi => fi.id === 'stopAttribution.config'))
+                                    subs.push('stopAttributionConfig');
+                                if (featureItems.some(fi => fi.id === 'stopAttribution.stripCommit'))
+                                    subs.push('stripCommitAttribution');
+                                if (featureItems.some(fi => fi.id === 'stopAttribution.renameBranch'))
+                                    subs.push('renameClaudeBranch');
+                                if (featureItems.some(fi => fi.id === 'stopAttribution.stripPr'))
+                                    subs.push('stripPrAttribution');
+                                if (featureItems.some(fi => fi.id === 'stopAttribution.mdFile'))
+                                    subs.push('agentMdFile');
+                                const count = subs.filter(f => sel.features.has(f)).length;
+                                if (count === subs.length)
+                                    return 'checked';
+                                if (count > 0)
+                                    return 'partial';
+                                return 'unchecked';
+                            }
+                            return sel.features.has(item.id) ? 'checked' : 'unchecked';
+                        } }), _jsx(PanelBox, { num: "4", title: "Git Settings", active: panel === 'gitSettings', items: gitSettingItems, cursor: cursors.gitSettings, isChecked: item => sel.gitSettings.has(item.id) ? 'checked' : 'unchecked' })] }), warning && _jsxs(Text, { color: "red", children: ["\u26A0 ", warning] }), _jsx(Text, { dimColor: true, children: "\u2191\u2193 change selection  space toggle  enter confirm  1/2/3/4 jump panel  q quit" })] }));
+};
+// ── ConfirmScreen ─────────────────────────────────────────────────────────────
+const ConfirmScreen = ({ selection, onConfirm, onBack }) => {
+    const { exit } = useApp();
+    useInput((input, key) => {
+        if (input === 'y' || input === 'Y') {
+            onConfirm();
+            return;
+        }
+        if (input === 'n' || input === 'N' || key.escape) {
+            onBack();
+            return;
+        }
+        if (input === 'q')
+            exit();
+    });
+    const scopeLabel = [...selection.scopes].map(s => SCOPE_LABELS[s]).join(' + ');
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "red", children: "The following will be removed:" }), _jsxs(Box, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [FEATURE_ORDER.filter(f => selection.features.has(f)).map(f => (_jsxs(Text, { children: ["  \u2022 ", FEATURE_LABELS[f]] }, f))), scopeLabel && _jsxs(Text, { dimColor: true, children: ["  Scope: ", scopeLabel] })] }), _jsxs(Text, { children: ["Continue? ", _jsx(Text, { bold: true, color: "yellow", children: "[y/N]" })] })] }));
+};
+// ── UninstallScreen ───────────────────────────────────────────────────────────
+const TAIL = 4;
+const UninstallScreen = ({ selection }) => {
+    const { exit } = useApp();
+    const [steps, setSteps] = useState(() => buildSteps(selection));
+    const [finished, setFinished] = useState(false);
+    const updateStep = useCallback((id, update) => {
+        setSteps(prev => prev.map(s => {
+            if (s.id !== id)
+                return s;
+            return {
+                ...s,
+                ...(update.status ? { status: update.status } : {}),
+                lines: update.line ? [...s.lines, update.line] : s.lines,
+            };
+        }));
+    }, []);
+    useEffect(() => {
+        runUninstall(selection, updateStep)
+            .then(() => { if (selection.gitSettings.has('gitignore'))
+            removeGitignoreEntries(); })
+            .finally(() => setFinished(true));
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => { if (finished)
+        exit(); }, [finished]); // eslint-disable-line react-hooks/exhaustive-deps
+    const allDone = steps.every(s => s.status === 'done' || s.status === 'skipped');
+    const hasError = steps.some(s => s.status === 'error');
+    const agentList = AGENT_IDS.filter(a => selection.agents.has(a)).map(a => AGENT_LABELS[a]).join(', ');
+    const scopeList = SCOPE_IDS.filter(s => selection.scopes.has(s)).map(s => SCOPE_LABELS[s]).join(', ');
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, children: "Uninstalling..." }), _jsx(Text, { dimColor: true, children: agentList }), _jsx(Text, { dimColor: true, children: scopeList }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: steps.map(step => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsx(StatusIcon, { status: step.status }), _jsx(Text, { children: step.label })] }), step.status === 'running' && step.lines.slice(-TAIL).map((l, i) => (_jsxs(Text, { dimColor: true, children: ["    ", l] }, i))), step.status === 'error' && step.lines.slice(-TAIL).map((l, i) => (_jsxs(Text, { color: "red", children: ["    ", l] }, i)))] }, step.id))) }), finished && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: hasError ? 'red' : 'green', children: hasError ? '✗ Completed with errors' : '✓ Done' }) }))] }));
+};
+export const App = () => {
+    const [screen, setScreen] = useState('select');
+    const [selection, setSelection] = useState(() => detectInstalled());
+    if (screen === 'select') {
+        return (_jsx(SelectScreen, { initialSel: selection, onConfirm: sel => { setSelection(sel); setScreen('confirm'); } }));
+    }
+    if (screen === 'confirm') {
+        return (_jsx(ConfirmScreen, { selection: selection, onConfirm: () => setScreen('uninstall'), onBack: () => setScreen('select') }));
+    }
+    return _jsx(UninstallScreen, { selection: selection });
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@buffbirb/unclaude",
+  "version": "1.0.0",
+  "description": "An opinionated AI dev tool setup script with a terminal UI. Configure privacy, code intelligence, and tool wrappers for Claude Code and OpenCode.",
+  "type": "module",
+  "keywords": [
+    "ai",
+    "claude",
+    "opencode",
+    "cli",
+    "terminal",
+    "setup",
+    "developer-tools",
+    "privacy",
+    "lsp",
+    "headroom",
+    "openspec"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "bin": {
+    "unclaude": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.tsx",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "commander": "^14.0.3",
+    "ink": "^5.0.1",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^18.3.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}