@buffbirb/unclaude 1.0.0

package/dist/common.js

@@ -0,0 +1,526 @@
+import { execFile, execFileSync, spawn } from 'child_process';
+import { promisify } from 'util';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, chmodSync, accessSync, constants, } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+// ── Paths ────────────────────────────────────────────────────────────────────
+export const HOME = homedir();
+export const AIRC = join(HOME, '.airc');
+export const ZSHRC = join(HOME, '.zshrc');
+export const CLAUDE_SETTINGS = join(HOME, '.claude', 'settings.json');
+export const OPENCODE_CONFIG = join(HOME, '.config', 'opencode', 'opencode.json');
+export const HCLAUDE = '/usr/local/bin/hclaude';
+export const HOPENCODE = '/usr/local/bin/hopencode';
+export const AGENT_IDS = ['claudeCode', 'openCode'];
+export const SCOPE_IDS = ['global', 'project'];
+export const GIT_SETTING_IDS = ['gitignore'];
+export const AGENT_LABELS = {
+    claudeCode: 'Claude Code',
+    openCode: 'OpenCode',
+};
+export const SCOPE_LABELS = {
+    global: 'Global',
+    project: 'Project',
+};
+export const GIT_SETTING_LABELS = {
+    gitignore: '.gitignore',
+};
+export const FEATURE_LABELS = {
+    headroom: 'Headroom',
+    stopTelemetry: 'Stop Telemetry',
+    stopAttributionConfig: 'Agent config for git commits',
+    stopAttributionHook: 'Git pre-commit hook for git commits',
+    stripCommitAttribution: 'Agent SessionStart hook for git commits',
+    stripPrAttribution: 'GitHub Action for PR body',
+    renameClaudeBranch: 'Agent SessionStart hook for git branches',
+    agentMdFile: 'Agent md file for all git ops',
+    lsp: 'LSP',
+    openspec: 'OpenSpec',
+};
+export const FEATURE_ORDER = [
+    'stopTelemetry', 'stopAttributionConfig', 'stopAttributionHook',
+    'stripCommitAttribution', 'renameClaudeBranch', 'stripPrAttribution',
+    'agentMdFile', 'lsp', 'headroom', 'openspec',
+];
+export const FEATURE_SCOPES = {
+    headroom: ['global'],
+    stopTelemetry: ['global'],
+    stopAttributionConfig: ['global', 'project'],
+    stopAttributionHook: ['project'],
+    stripCommitAttribution: ['project'],
+    stripPrAttribution: ['project'],
+    renameClaudeBranch: ['project'],
+    agentMdFile: ['global', 'project'],
+    lsp: ['global'],
+    openspec: ['global', 'project'],
+};
+export const FEATURE_AGENTS = {
+    stopTelemetry: ['claudeCode'],
+    stopAttributionConfig: ['claudeCode'],
+    stopAttributionHook: ['claudeCode', 'openCode'],
+    stripCommitAttribution: ['claudeCode'],
+    renameClaudeBranch: ['claudeCode'],
+    stripPrAttribution: ['claudeCode', 'openCode'],
+    agentMdFile: ['claudeCode', 'openCode'],
+    lsp: ['claudeCode', 'openCode'],
+    headroom: ['claudeCode', 'openCode'],
+    openspec: ['claudeCode', 'openCode'],
+};
+export const DEFAULT_FEATURES = [
+    'stopTelemetry', 'stopAttributionConfig', 'stopAttributionHook',
+    'stripCommitAttribution', 'renameClaudeBranch', 'stripPrAttribution',
+    'agentMdFile',
+];
+export function defaultSelection() {
+    return {
+        agents: new Set(['claudeCode', 'openCode']),
+        scopes: new Set(['global', 'project']),
+        features: new Set(DEFAULT_FEATURES),
+        lspLanguages: new Set(),
+        gitSettings: new Set(['gitignore']),
+    };
+}
+export function getFeatureItems(agents, scopes) {
+    const supportsScope = (feature) => {
+        if (scopes.size === 0)
+            return false;
+        return FEATURE_SCOPES[feature].some(s => scopes.has(s));
+    };
+    const supportsAgent = (feature) => {
+        if (agents.size === 0)
+            return false;
+        return FEATURE_AGENTS[feature].some(a => agents.has(a));
+    };
+    const supported = (feature) => supportsScope(feature) && supportsAgent(feature);
+    const items = [];
+    if (supported('stopTelemetry')) {
+        items.push({ id: 'stopTelemetry', label: FEATURE_LABELS.stopTelemetry, indent: false });
+    }
+    const stopAttributionChildren = [
+        { id: 'stopAttribution.hook', feature: 'stopAttributionHook', label: FEATURE_LABELS.stopAttributionHook },
+        { id: 'stopAttribution.config', feature: 'stopAttributionConfig', label: FEATURE_LABELS.stopAttributionConfig },
+        { id: 'stopAttribution.stripCommit', feature: 'stripCommitAttribution', label: FEATURE_LABELS.stripCommitAttribution },
+        { id: 'stopAttribution.renameBranch', feature: 'renameClaudeBranch', label: FEATURE_LABELS.renameClaudeBranch },
+        { id: 'stopAttribution.stripPr', feature: 'stripPrAttribution', label: FEATURE_LABELS.stripPrAttribution },
+        { id: 'stopAttribution.mdFile', feature: 'agentMdFile', label: FEATURE_LABELS.agentMdFile },
+    ].filter(c => supported(c.feature));
+    if (stopAttributionChildren.length > 0) {
+        items.push({ id: 'stopAttribution', label: 'Stop Attribution', indent: false });
+        for (const child of stopAttributionChildren) {
+            items.push({ id: child.id, label: child.label, indent: true });
+        }
+    }
+    if (supported('lsp')) {
+        items.push({ id: 'lsp', label: FEATURE_LABELS.lsp, indent: false });
+        if (agents.has('claudeCode')) {
+            items.push({ id: 'lsp.cpp', label: 'C++ (clangd)', indent: true }, { id: 'lsp.swift', label: 'Swift', indent: true });
+        }
+    }
+    if (supported('headroom')) {
+        items.push({ id: 'headroom', label: FEATURE_LABELS.headroom, indent: false });
+    }
+    if (supported('openspec')) {
+        items.push({ id: 'openspec', label: FEATURE_LABELS.openspec, indent: false });
+    }
+    return items;
+}
+export function toggleSelection(panel, cursor, sel, featureItems) {
+    const next = {
+        agents: new Set(sel.agents),
+        scopes: new Set(sel.scopes),
+        features: new Set(sel.features),
+        lspLanguages: new Set(sel.lspLanguages),
+        gitSettings: new Set(sel.gitSettings),
+    };
+    if (panel === 'agents') {
+        const id = AGENT_IDS[cursor];
+        if (!id)
+            return sel;
+        if (next.agents.has(id)) {
+            next.agents.delete(id);
+        }
+        else {
+            next.agents.add(id);
+        }
+    }
+    else if (panel === 'scope') {
+        const id = SCOPE_IDS[cursor];
+        if (!id)
+            return sel;
+        if (next.scopes.has(id))
+            next.scopes.delete(id);
+        else
+            next.scopes.add(id);
+    }
+    else if (panel === 'gitSettings') {
+        const id = GIT_SETTING_IDS[cursor];
+        if (!id)
+            return sel;
+        if (next.gitSettings.has(id))
+            next.gitSettings.delete(id);
+        else
+            next.gitSettings.add(id);
+    }
+    else {
+        const item = featureItems[cursor];
+        if (!item)
+            return sel;
+        if (item.id === 'lsp.cpp') {
+            if (next.lspLanguages.has('cpp'))
+                next.lspLanguages.delete('cpp');
+            else
+                next.lspLanguages.add('cpp');
+            if (next.lspLanguages.size > 0)
+                next.features.add('lsp');
+            else
+                next.features.delete('lsp');
+        }
+        else if (item.id === 'lsp.swift') {
+            if (next.lspLanguages.has('swift'))
+                next.lspLanguages.delete('swift');
+            else
+                next.lspLanguages.add('swift');
+            if (next.lspLanguages.size > 0)
+                next.features.add('lsp');
+            else
+                next.features.delete('lsp');
+        }
+        else if (item.id === 'stopAttribution.hook') {
+            if (next.features.has('stopAttributionHook'))
+                next.features.delete('stopAttributionHook');
+            else
+                next.features.add('stopAttributionHook');
+        }
+        else if (item.id === 'stopAttribution.config') {
+            if (next.features.has('stopAttributionConfig'))
+                next.features.delete('stopAttributionConfig');
+            else
+                next.features.add('stopAttributionConfig');
+        }
+        else if (item.id === 'stopAttribution.stripCommit') {
+            if (next.features.has('stripCommitAttribution'))
+                next.features.delete('stripCommitAttribution');
+            else
+                next.features.add('stripCommitAttribution');
+        }
+        else if (item.id === 'stopAttribution.stripPr') {
+            if (next.features.has('stripPrAttribution'))
+                next.features.delete('stripPrAttribution');
+            else
+                next.features.add('stripPrAttribution');
+        }
+        else if (item.id === 'stopAttribution.renameBranch') {
+            if (next.features.has('renameClaudeBranch'))
+                next.features.delete('renameClaudeBranch');
+            else
+                next.features.add('renameClaudeBranch');
+        }
+        else if (item.id === 'stopAttribution.mdFile') {
+            if (next.features.has('agentMdFile'))
+                next.features.delete('agentMdFile');
+            else
+                next.features.add('agentMdFile');
+        }
+        else if (item.id === 'stopAttribution') {
+            const visibleSubs = [];
+            if (featureItems.some(fi => fi.id === 'stopAttribution.hook'))
+                visibleSubs.push('stopAttributionHook');
+            if (featureItems.some(fi => fi.id === 'stopAttribution.config'))
+                visibleSubs.push('stopAttributionConfig');
+            if (featureItems.some(fi => fi.id === 'stopAttribution.stripCommit'))
+                visibleSubs.push('stripCommitAttribution');
+            if (featureItems.some(fi => fi.id === 'stopAttribution.renameBranch'))
+                visibleSubs.push('renameClaudeBranch');
+            if (featureItems.some(fi => fi.id === 'stopAttribution.stripPr'))
+                visibleSubs.push('stripPrAttribution');
+            if (featureItems.some(fi => fi.id === 'stopAttribution.mdFile'))
+                visibleSubs.push('agentMdFile');
+            if (visibleSubs.length === 0)
+                return sel;
+            const allOn = visibleSubs.every(f => next.features.has(f));
+            if (allOn)
+                visibleSubs.forEach(f => next.features.delete(f));
+            else
+                visibleSubs.forEach(f => next.features.add(f));
+        }
+        else {
+            const id = item.id;
+            if (next.features.has(id)) {
+                next.features.delete(id);
+                if (id === 'lsp')
+                    next.lspLanguages.clear();
+            }
+            else {
+                next.features.add(id);
+                if (id === 'lsp') {
+                    next.lspLanguages.add('cpp');
+                    next.lspLanguages.add('swift');
+                }
+            }
+        }
+    }
+    return next;
+}
+// ── Exec utilities ───────────────────────────────────────────────────────────
+const execFileAsync = promisify(execFile);
+export async function run(cmd, args = []) {
+    const { stdout } = await execFileAsync(cmd, args);
+    return stdout.trim();
+}
+export function stream(cmd, args, onLine, opts) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(cmd, args, {
+            shell: false,
+            env: opts?.env ?? process.env,
+            cwd: opts?.cwd,
+        });
+        const emit = (data) => String(data).split('\n').filter(Boolean).forEach(onLine);
+        proc.stdout.on('data', emit);
+        proc.stderr.on('data', emit);
+        proc.on('close', code => (code === 0 ? resolve() : reject(new Error(`${cmd} exited ${code}`))));
+        proc.on('error', reject);
+    });
+}
+export function commandExists(cmd) {
+    try {
+        execFileSync('which', [cmd], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isGitRepo() {
+    try {
+        execFileSync('git', ['rev-parse', '--git-dir'], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function canWrite(path) {
+    try {
+        accessSync(path, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function nvmShell(cmd, onLine) {
+    const nvmDir = join(HOME, '.nvm');
+    await stream('bash', ['-c', `. "${nvmDir}/nvm.sh" && ${cmd}`], onLine, {
+        env: { ...process.env, NVM_DIR: nvmDir },
+    });
+}
+// ── File utilities ───────────────────────────────────────────────────────────
+export function readJson(filePath) {
+    if (!existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeJson(filePath, data) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+export function patchJson(filePath, patch) {
+    const data = readJson(filePath);
+    patch(data);
+    writeJson(filePath, data);
+}
+export function ensureFile(filePath, defaultContent) {
+    if (!existsSync(filePath)) {
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, defaultContent);
+    }
+}
+export function appendIfMissing(filePath, marker, content) {
+    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+    if (!existing.includes(marker))
+        appendFileSync(filePath, content);
+}
+export async function writeExecutable(filePath, content, onLine) {
+    if (canWrite(dirname(filePath))) {
+        writeFileSync(filePath, content);
+        chmodSync(filePath, 0o755);
+    }
+    else {
+        onLine(`sudo required for ${filePath}`);
+        await new Promise((resolve, reject) => {
+            const proc = spawn('sudo', ['tee', filePath], { stdio: ['pipe', 'ignore', 'pipe'] });
+            proc.stdin.write(content);
+            proc.stdin.end();
+            proc.on('close', c => (c === 0 ? resolve() : reject(new Error('sudo tee failed'))));
+            proc.on('error', reject);
+        });
+        await run('sudo', ['chmod', '+x', filePath]);
+    }
+}
+// ── Template strings ─────────────────────────────────────────────────────────
+export const HEADROOM_START_FUNC = `
+headroom_start() {
+  if ! lsof -ti:8787 > /dev/null 2>&1; then
+    HEADROOM_CODE_AWARE_ENABLED=1 headroom proxy --port 8787 > /dev/null 2>&1 &
+    disown
+  fi
+}
+`;
+export const HCLAUDE_CONTENT = `#!/bin/sh
+. ~/.airc
+headroom_start
+ANTHROPIC_BASE_URL=http://localhost:8787 claude "$@"
+`;
+export const HOPENCODE_CONTENT = `#!/bin/sh
+. ~/.airc
+headroom_start
+OPENAI_BASE_URL=http://localhost:8787/v1 opencode "$@"
+`;
+// Bash commit-msg hook used by the SessionStart strip-commit-attribution script.
+export const BASH_COMMIT_MSG_HOOK = `#!/bin/bash
+sed -i '' \\
+  -e '/claude\\.ai\\/code\\/session/d' \\
+  -e '/Co-[Aa]uthored-[Bb]y:.*[Cc]laude/d' \\
+  -e '/[Gg]enerated [bw][yi]t*h*.*[Cc]laude/d' \\
+  -e '/[[:space:]]*🤖 [Gg]enerated/d' \\
+  -e '/^---[[:space:]]*$/d' \\
+  "$1"
+awk 'BEGIN{blank=0} /^$/{blank++; next} {while(blank--)print ""; blank=0; print}' "$1" > "$1.tmp" && mv "$1.tmp" "$1"
+`;
+// GitHub Actions workflow that strips Claude attribution from PR bodies server-side.
+export const STRIP_PR_WORKFLOW = `name: Strip Claude attribution from PR bodies
+
+on:
+  pull_request:
+    types: [opened, edited]
+
+permissions:
+  pull-requests: write
+  contents: read
+
+jobs:
+  strip:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Strip attribution lines
+        env:
+          GH_TOKEN: ${'$'}{{ secrets.GITHUB_TOKEN }}
+          PR: ${'$'}{{ github.event.pull_request.number }}
+          REPO: ${'$'}{{ github.repository }}
+        run: |
+          set -e
+          body=$(gh pr view "$PR" -R "$REPO" --json body --jq .body)
+          cleaned=$(printf '%s' "$body" | sed \\
+            -e '/claude\\.ai\\/code\\/session/d' \\
+            -e '/Co-[Aa]uthored-[Bb]y:.*[Cc]laude/d' \\
+            -e '/[Gg]enerated [bw][yi]t*h*.*[Cc]laude/d' \\
+            -e '/[[:space:]]*🤖 [Gg]enerated/d' \\
+            -e '/^---[[:space:]]*$/d' \\
+            | awk 'BEGIN{blank=0} /^$/{blank++; next} {while(blank--)print ""; blank=0; print}')
+          if [ "$body" = "$cleaned" ]; then
+            echo "PR #$PR body already clean"
+            exit 0
+          fi
+          printf '%s' "$cleaned" | gh pr edit "$PR" -R "$REPO" --body-file -
+          echo "Cleaned PR #$PR"
+`;
+// ── Agent markdown file content ──────────────────────────────────────────────
+export const AGENT_MD_HEADER = '# UNCLAUDE';
+const FEATURE_PROJECT_FILES = {
+    stopAttributionConfig: ['.claude/settings.json'],
+    stripCommitAttribution: ['.claude/settings.json', '.claude/hooks/strip-commit-attribution.sh'],
+    renameClaudeBranch: ['.claude/settings.json', '.claude/hooks/strip-claude-branch.sh'],
+    stripPrAttribution: ['.github/workflows/strip-pr-attribution.yml'],
+    agentMdFile: ['CLAUDE.md', 'AGENTS.md'],
+};
+export function addGitignoreEntries(features) {
+    const files = new Set();
+    for (const feature of features) {
+        for (const p of FEATURE_PROJECT_FILES[feature] ?? [])
+            files.add(p);
+    }
+    if (files.size === 0)
+        return;
+    appendSectionIfMissing('.gitignore', AGENT_MD_HEADER, `${AGENT_MD_HEADER}\n${[...files].join('\n')}`);
+}
+export function removeGitignoreEntries() {
+    removeSectionByHeader('.gitignore', AGENT_MD_HEADER);
+}
+// ── Markdown section helpers ─────────────────────────────────────────────────
+export function appendSectionIfMissing(filePath, marker, content) {
+    const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+    if (!existing.includes(marker)) {
+        const sep = existing.length > 0 && !existing.endsWith('\n') ? '\n\n' : (existing.endsWith('\n') ? '\n' : '');
+        writeFileSync(filePath, existing + sep + content + '\n');
+    }
+}
+export function removeSectionByHeader(filePath, header) {
+    if (!existsSync(filePath))
+        return false;
+    const content = readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const startIdx = lines.findIndex(l => l.trim() === header);
+    if (startIdx === -1)
+        return false;
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (lines[i].startsWith('# ')) {
+            endIdx = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, startIdx);
+    const after = lines.slice(endIdx);
+    while (before.length > 0 && before[before.length - 1].trim() === '')
+        before.pop();
+    while (after.length > 0 && after[0].trim() === '')
+        after.shift();
+    let newContent = [...before, ...after].join('\n');
+    if (newContent.length > 0 && !newContent.endsWith('\n'))
+        newContent += '\n';
+    writeFileSync(filePath, newContent);
+    return true;
+}
+// ── SessionStart hook helpers ─────────────────────────────────────────────────
+export function addSessionStartHook(settingsPath, command) {
+    patchJson(settingsPath, d => {
+        if (typeof d['hooks'] !== 'object' || !d['hooks'])
+            d['hooks'] = {};
+        const h = d['hooks'];
+        if (!Array.isArray(h['SessionStart']))
+            h['SessionStart'] = [];
+        const arr = h['SessionStart'];
+        const exists = arr.some(g => {
+            const inner = g['hooks'];
+            return inner?.some(e => e['command'] === command);
+        });
+        if (!exists)
+            arr.push({ hooks: [{ type: 'command', command }] });
+    });
+}
+export function removeSessionStartHook(settingsPath, command) {
+    patchJson(settingsPath, d => {
+        const h = d['hooks'];
+        if (!h || !Array.isArray(h['SessionStart']))
+            return;
+        h['SessionStart'] = h['SessionStart'].filter(g => {
+            const inner = g['hooks'];
+            return !inner?.some(e => e['command'] === command);
+        });
+    });
+}
+export function hasSessionStartHook(settingsPath, command) {
+    const d = readJson(settingsPath);
+    const h = d['hooks'];
+    if (!h || !Array.isArray(h['SessionStart']))
+        return false;
+    return h['SessionStart'].some(g => {
+        const inner = g['hooks'];
+        return inner?.some(e => e['command'] === command);
+    });
+}