icopilot 2.2.0

package/dist/commands/git-extra.js

@@ -0,0 +1,197 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import simpleGit from 'simple-git';
+import { confirm } from '@inquirer/prompts';
+import { config } from '../config.js';
+import { streamChat } from '../api/github-models.js';
+import { renderMarkdownString } from '../ui/render.js';
+import { theme } from '../ui/theme.js';
+function git() {
+    return simpleGit({ baseDir: config.cwd });
+}
+const REVIEW_PROMPT = `You are reviewing staged git changes.
+Surface only meaningful bugs, security risks, performance issues, missing tests, and concrete suggestions.
+Use Markdown with severity labels. If no issues are found, say so briefly.`;
+const ISSUE_PROMPT = `Draft a GitHub issue from repository context.
+Output Markdown only:
+# <concise title>
+
+## Context
+## Problem / Opportunity
+## Proposed Work
+## Acceptance Criteria
+## Notes / Risks`;
+export async function reviewStaged(session, signal) {
+    let staged = '';
+    try {
+        staged = await git().diff(['--cached']);
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`git failed: ${e?.message}\n`));
+        return;
+    }
+    if (!staged.trim()) {
+        process.stdout.write(theme.warn('No staged changes. Stage files with `git add` first.\n'));
+        return;
+    }
+    const messages = [
+        { role: 'system', content: REVIEW_PROMPT },
+        {
+            role: 'user',
+            content: `Model: ${session.state.model}\nReview this staged diff:\n\n` + staged.slice(0, 80_000),
+        },
+    ];
+    process.stdout.write(theme.dim('Reviewing staged changes…\n\n'));
+    await streamChat({
+        model: session.state.model,
+        messages,
+        temperature: 0.2,
+        signal,
+        onToken: (t) => process.stdout.write(t),
+    });
+    process.stdout.write('\n');
+}
+export async function draftIssue(session, signal, title) {
+    const g = git();
+    try {
+        const branch = (await g.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+        const base = await defaultBranch(g);
+        const log = await g.raw(['log', `${base}..HEAD`, '--pretty=format:%h %s']).catch(() => '');
+        const diff = await g.raw(['diff', `${base}...HEAD`]).catch(() => '');
+        const status = await g.status();
+        const messages = [
+            { role: 'system', content: ISSUE_PROMPT },
+            {
+                role: 'user',
+                content: `Model: ${session.state.model}\n` +
+                    `Requested title: ${title || '(infer one)'}\n` +
+                    `Branch: ${branch}\nDefault branch: ${base}\n` +
+                    `Status: ${JSON.stringify(status, null, 2)}\n\n` +
+                    `Recent commits:\n${log || '(none)'}\n\n` +
+                    `Diff vs ${base}:\n${diff.slice(0, 80_000) || '(none)'}`,
+            },
+        ];
+        process.stdout.write(theme.dim('Drafting issue…\n'));
+        let md = '';
+        await streamChat({
+            model: session.state.model,
+            messages,
+            temperature: 0.3,
+            signal,
+            onToken: (t) => {
+                md += t;
+            },
+        });
+        const issueTitle = title || extractTitle(md);
+        const body = stripTitle(md).trim() || md.trim();
+        process.stdout.write('\n' + (await renderMarkdownString(md)) + '\n');
+        await offerClipboard(md);
+        await offerGhIssue(issueTitle, body);
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`/issue failed: ${e?.message}\n`));
+    }
+}
+export async function scaffoldBranch(_session, _signal, topic) {
+    if (!topic.trim()) {
+        process.stdout.write(theme.warn('Usage: /branch <topic>\n'));
+        return;
+    }
+    const name = branchName(topic);
+    process.stdout.write(theme.dim(`Suggested branch: ${name}\n`));
+    if (!commandExists('git')) {
+        process.stdout.write(theme.warn('git is not available on PATH.\n'));
+        return;
+    }
+    const ok = await confirm({ message: `Create and checkout ${name}?`, default: true }).catch(() => false);
+    if (!ok)
+        return;
+    try {
+        await git().raw(['checkout', '-b', name]);
+        process.stdout.write(theme.ok(`✔ checked out ${name}\n`));
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`branch failed: ${e?.message}\n`));
+    }
+}
+async function defaultBranch(g) {
+    try {
+        const remote = await g.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+        const match = remote.match(/refs\/remotes\/origin\/(.+)/);
+        if (match)
+            return match[1].trim();
+    }
+    catch {
+        /* fall through */
+    }
+    for (const candidate of ['main', 'master', 'develop']) {
+        try {
+            await g.raw(['rev-parse', '--verify', candidate]);
+            return candidate;
+        }
+        catch {
+            /* keep trying */
+        }
+    }
+    return 'main';
+}
+function extractTitle(md) {
+    const heading = md.match(/^#\s+(.+)$/m);
+    return (heading?.[1] || 'Issue drafted by iCopilot').trim();
+}
+function stripTitle(md) {
+    return md.replace(/^#\s+.+\r?\n+/, '');
+}
+async function offerClipboard(text) {
+    const ok = await confirm({ message: 'Copy issue draft to clipboard?', default: false }).catch(() => false);
+    if (!ok)
+        return;
+    const command = process.platform === 'win32' ? 'clip' : process.platform === 'darwin' ? 'pbcopy' : 'xclip';
+    const args = process.platform === 'linux' ? ['-selection', 'clipboard'] : [];
+    const child = spawn(command, args, { stdio: ['pipe', 'ignore', 'ignore'], windowsHide: true });
+    child.stdin.end(text);
+}
+async function offerGhIssue(title, body) {
+    if (!commandExists('gh'))
+        return;
+    const ok = await confirm({ message: 'Create issue with gh CLI?', default: false }).catch(() => false);
+    if (!ok)
+        return;
+    const file = path.join(config.cwd, `.icopilot-issue-${Date.now()}.md`);
+    try {
+        await fs.writeFile(file, body + '\n', 'utf8');
+        await run('gh', ['issue', 'create', '--title', title, '--body-file', file], config.cwd);
+    }
+    finally {
+        await fs.rm(file, { force: true }).catch(() => undefined);
+    }
+}
+function branchName(topic) {
+    const cleaned = topic
+        .trim()
+        .toLowerCase()
+        .replace(/['"]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 48)
+        .replace(/-+$/g, '');
+    const prefix = /^(fix|bug|hotfix)\b/.test(topic.toLowerCase()) ? 'fix' : 'feat';
+    return `${prefix}/${cleaned || 'work'}`;
+}
+function commandExists(command) {
+    const checker = process.platform === 'win32' ? 'where.exe' : 'which';
+    return spawnSync(checker, [command], { stdio: 'ignore' }).status === 0;
+}
+function run(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd, stdio: 'inherit', windowsHide: true });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`${command} exited with code ${code}`));
+        });
+    });
+}

package/dist/commands/git-log-cmd.js

@@ -0,0 +1,98 @@
+import simpleGit from 'simple-git';
+import { theme } from '../ui/theme.js';
+const DEFAULT_COUNT = 15;
+const MAX_COUNT = 100;
+const USAGE = 'Usage: /git-log [--count <n>|-n <n>] [--author <name>] [--since <date>] [branch]';
+export async function gitLogCommand(args, cwd) {
+    let parsed;
+    try {
+        parsed = parseArgs(args);
+    }
+    catch (error) {
+        return `${theme.warn(error.message)}\n`;
+    }
+    const git = simpleGit({ baseDir: cwd });
+    try {
+        if (!(await git.checkIsRepo())) {
+            return `${theme.warn(`Not a git repository: ${cwd}`)}\n`;
+        }
+        const logArgs = [`--max-count=${parsed.count}`];
+        if (parsed.author)
+            logArgs.push(`--author=${parsed.author}`);
+        if (parsed.since)
+            logArgs.push(`--since=${parsed.since}`);
+        if (parsed.branch)
+            logArgs.push(parsed.branch);
+        const result = await git.log(logArgs);
+        if (result.all.length === 0)
+            return `${theme.dim('No commits found.')}\n`;
+        const entries = result.all.map(toLogEntry);
+        return `${entries.map(formatLogEntry).join('\n')}\n`;
+    }
+    catch (error) {
+        if (isNotGitRepositoryError(error)) {
+            return `${theme.warn(`Not a git repository: ${cwd}`)}\n`;
+        }
+        return `${theme.err(`git log failed: ${error.message}`)}\n`;
+    }
+}
+export function formatLogEntry(entry) {
+    const refs = entry.refs.length > 0 ? ` ${theme.hl(`(${entry.refs.join(', ')})`)}` : '';
+    return `${theme.dim(entry.shortHash)} ${entry.subject} ${theme.user(entry.author)} ${theme.dim(entry.date)}${refs}`;
+}
+function parseArgs(args) {
+    const parsed = { count: DEFAULT_COUNT };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--count' || arg === '-n') {
+            const rawCount = args[++i];
+            const count = Number.parseInt(rawCount ?? '', 10);
+            if (!Number.isInteger(count) || count <= 0) {
+                throw new Error(USAGE);
+            }
+            parsed.count = Math.min(count, MAX_COUNT);
+            continue;
+        }
+        if (arg === '--author') {
+            const author = args[++i]?.trim();
+            if (!author)
+                throw new Error(USAGE);
+            parsed.author = author;
+            continue;
+        }
+        if (arg === '--since') {
+            const since = args[++i]?.trim();
+            if (!since)
+                throw new Error(USAGE);
+            parsed.since = since;
+            continue;
+        }
+        if (arg.startsWith('-'))
+            throw new Error(USAGE);
+        if (parsed.branch)
+            throw new Error(USAGE);
+        parsed.branch = arg;
+    }
+    return parsed;
+}
+function toLogEntry(entry) {
+    return {
+        hash: entry.hash,
+        shortHash: entry.hash.slice(0, 7),
+        subject: entry.message,
+        author: entry.author_name,
+        date: entry.date,
+        refs: parseRefs(entry.refs),
+    };
+}
+function parseRefs(refs) {
+    if (!refs.trim())
+        return [];
+    return refs
+        .split(',')
+        .map((ref) => ref.trim())
+        .filter(Boolean);
+}
+function isNotGitRepositoryError(error) {
+    return error instanceof Error && /not a git repository/i.test(error.message);
+}

package/dist/commands/git-undo-cmd.js

@@ -0,0 +1,137 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import simpleGit from 'simple-git';
+import { config } from '../config.js';
+import { theme } from '../ui/theme.js';
+const AI_COMMITS_ENV = 'ICOPILOT_AI_COMMITS_PATH';
+const AI_COMMITS_LIMIT = 200;
+function git(cwd = config.cwd) {
+    return simpleGit({ baseDir: cwd });
+}
+export function aiCommitsPath() {
+    return process.env[AI_COMMITS_ENV] || path.join(os.homedir(), '.icopilot', 'ai-commits.json');
+}
+function ensureStateDir() {
+    fs.mkdirSync(path.dirname(aiCommitsPath()), { recursive: true });
+}
+function emptyState() {
+    return { commits: [] };
+}
+function normalizeState(candidate) {
+    if (!candidate || typeof candidate !== 'object')
+        return emptyState();
+    const parsed = candidate;
+    return {
+        commits: Array.isArray(parsed.commits)
+            ? parsed.commits.filter((value) => typeof value === 'string' && value.trim().length > 0)
+            : [],
+    };
+}
+function loadState() {
+    ensureStateDir();
+    try {
+        return normalizeState(JSON.parse(fs.readFileSync(aiCommitsPath(), 'utf8')));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return emptyState();
+        return emptyState();
+    }
+}
+function saveState(state) {
+    ensureStateDir();
+    fs.writeFileSync(aiCommitsPath(), `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+function normalizeSha(sha) {
+    return sha.trim().toLowerCase();
+}
+function matchesCommitSha(left, right) {
+    const a = normalizeSha(left);
+    const b = normalizeSha(right);
+    return Boolean(a) && Boolean(b) && (a === b || a.startsWith(b) || b.startsWith(a));
+}
+export function registerAiCommit(sha) {
+    const normalized = normalizeSha(sha);
+    if (!normalized)
+        return;
+    const state = loadState();
+    state.commits = state.commits.filter((entry) => !matchesCommitSha(entry, normalized));
+    state.commits.push(normalized);
+    state.commits = state.commits.slice(Math.max(0, state.commits.length - AI_COMMITS_LIMIT));
+    saveState(state);
+}
+function unregisterAiCommit(sha) {
+    const state = loadState();
+    const next = state.commits.filter((entry) => !matchesCommitSha(entry, sha));
+    if (next.length === state.commits.length)
+        return;
+    saveState({ commits: next });
+}
+function isTrackedAiCommit(sha) {
+    return loadState().commits.some((entry) => matchesCommitSha(entry, sha));
+}
+function looksLikeAiCommit(details) {
+    const haystack = `${details.subject}\n${details.body}\n${details.authorName}\n${details.authorEmail}`;
+    return /\bicopilot\b/i.test(haystack) || /\bcopilot\b/i.test(haystack);
+}
+async function loadHeadCommitDetails(g) {
+    const metaRaw = await g.raw(['show', '-s', '--format=%H%x1f%s%x1f%an%x1f%ae%x1f%B', 'HEAD']);
+    const [sha = '', subject = '', authorName = '', authorEmail = '', ...bodyParts] = metaRaw.split('\x1f');
+    const filesRaw = await g.raw(['show', '--pretty=format:', '--name-only', 'HEAD']);
+    return {
+        sha: sha.trim(),
+        subject: subject.trim(),
+        body: bodyParts.join('\x1f').trim(),
+        authorName: authorName.trim(),
+        authorEmail: authorEmail.trim(),
+        files: filesRaw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean),
+    };
+}
+function formatUndoSummary(details, hard) {
+    const files = details.files.length
+        ? details.files.map((file) => `  ${theme.dim('•')} ${file}`).join('\n')
+        : `  ${theme.dim('• no file list available')}`;
+    return (`${theme.ok(`✔ undid AI commit ${details.sha.slice(0, 7)}`)} ${details.subject}\n` +
+        `${theme.dim(hard ? 'mode: hard reset (changes discarded)' : 'mode: soft reset (changes kept staged)')}\n` +
+        `${theme.brand('Files')}\n${files}\n`);
+}
+function formatSafetyRefusal(details) {
+    return theme.warn(`Refusing to undo ${details.sha.slice(0, 7)} (${details.subject}) because it is not marked as an AI commit.\n`);
+}
+export async function gitUndo(options = {}) {
+    const g = git(options.cwd);
+    try {
+        const isRepo = await g.checkIsRepo();
+        if (!isRepo)
+            return theme.warn('Not a git repository.\n');
+        try {
+            await g.raw(['rev-parse', '--verify', 'HEAD']);
+        }
+        catch {
+            return theme.warn('No commits to undo.\n');
+        }
+        const details = await loadHeadCommitDetails(g);
+        const isAiCommit = isTrackedAiCommit(details.sha) || looksLikeAiCommit(details);
+        if (!isAiCommit)
+            return formatSafetyRefusal(details);
+        try {
+            await g.raw(['rev-parse', '--verify', 'HEAD~1']);
+        }
+        catch {
+            return theme.warn('Cannot undo the initial commit safely.\n');
+        }
+        await g.raw(['reset', options.hard ? '--hard' : '--soft', 'HEAD~1']);
+        unregisterAiCommit(details.sha);
+        return formatUndoSummary(details, Boolean(options.hard));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/not a git repository/i.test(message))
+            return theme.warn('Not a git repository.\n');
+        return theme.err(`git undo failed: ${message}\n`);
+    }
+}

package/dist/commands/git.js

@@ -0,0 +1,155 @@
+import simpleGit from 'simple-git';
+import { confirm } from '@inquirer/prompts';
+import { config } from '../config.js';
+import { streamChat } from '../api/github-models.js';
+import { theme } from '../ui/theme.js';
+import { renderMarkdownString } from '../ui/render.js';
+import { registerAiCommit } from './git-undo-cmd.js';
+function git() {
+    return simpleGit({ baseDir: config.cwd });
+}
+export async function showDiff() {
+    try {
+        const d = await git().diff();
+        if (!d.trim()) {
+            process.stdout.write(theme.dim('No unstaged changes.\n'));
+            const staged = await git().diff(['--cached']);
+            if (staged.trim()) {
+                process.stdout.write(theme.hl('Staged changes:\n') + colorize(staged) + '\n');
+            }
+            return;
+        }
+        process.stdout.write(colorize(d) + '\n');
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`git diff failed: ${e?.message}\n`));
+    }
+}
+const COMMIT_PROMPT = `You write semantic commit messages following Conventional Commits.
+Output ONLY the commit message — no fences, no commentary.
+Format:
+<type>(<optional scope>): <short summary in imperative mood, ≤72 chars>
+
+<optional body explaining what and why; wrap at 72 cols>`;
+export async function commitFromStaged(session, signal) {
+    let staged;
+    try {
+        staged = await git().diff(['--cached']);
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`git failed: ${e?.message}\n`));
+        return;
+    }
+    if (!staged.trim()) {
+        process.stdout.write(theme.warn('No staged changes. Stage files with `git add` first.\n'));
+        return;
+    }
+    const messages = [
+        { role: 'system', content: COMMIT_PROMPT },
+        { role: 'user', content: 'Generate a commit message for this diff:\n\n' + staged },
+    ];
+    process.stdout.write(theme.dim('Generating commit message…\n'));
+    let msg = '';
+    await streamChat({
+        model: session.state.model,
+        messages,
+        temperature: 0.2,
+        signal,
+        onToken: (t) => {
+            msg += t;
+            process.stdout.write(t);
+        },
+    });
+    msg = msg
+        .trim()
+        .replace(/^```[\w]*\n?|```$/g, '')
+        .trim();
+    process.stdout.write('\n');
+    const ok = await confirm({ message: 'Commit with this message?', default: false }).catch(() => false);
+    if (!ok)
+        return;
+    try {
+        const res = await git().commit(msg);
+        registerAiCommit(res.commit);
+        process.stdout.write(theme.ok(`✔ committed ${res.commit}\n`));
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`commit failed: ${e?.message}\n`));
+    }
+}
+const PR_PROMPT = `You write high-quality pull request descriptions in Markdown.
+Sections: ## Summary, ## Changes (bulleted), ## Why, ## Test plan, ## Risks.
+Be concise. Output Markdown only.`;
+export async function prDescription(session, signal) {
+    const g = git();
+    try {
+        // Determine default branch
+        let base = 'main';
+        try {
+            const remote = await g.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+            const m = remote.match(/refs\/remotes\/origin\/(.+)/);
+            if (m)
+                base = m[1].trim();
+        }
+        catch {
+            // try common fallbacks
+            for (const b of ['main', 'master', 'develop']) {
+                try {
+                    await g.raw(['rev-parse', '--verify', b]);
+                    base = b;
+                    break;
+                }
+                catch {
+                    /* keep trying */
+                }
+            }
+        }
+        const branch = (await g.raw(['rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+        if (branch === base) {
+            process.stdout.write(theme.warn(`On default branch (${base}); switch to a feature branch.\n`));
+            return;
+        }
+        const diff = await g.raw(['diff', `${base}...HEAD`]);
+        const log = await g.raw(['log', `${base}..HEAD`, '--pretty=format:%h %s']);
+        if (!diff.trim()) {
+            process.stdout.write(theme.warn(`No changes vs ${base}.\n`));
+            return;
+        }
+        const messages = [
+            { role: 'system', content: PR_PROMPT },
+            {
+                role: 'user',
+                content: `Branch: ${branch} → ${base}\n\nCommits:\n${log}\n\nDiff:\n${diff.slice(0, 60_000)}`,
+            },
+        ];
+        process.stdout.write(theme.dim(`Drafting PR description (${branch} → ${base})…\n`));
+        let md = '';
+        await streamChat({
+            model: session.state.model,
+            messages,
+            temperature: 0.3,
+            signal,
+            onToken: (t) => {
+                md += t;
+            },
+        });
+        process.stdout.write('\n' + (await renderMarkdownString(md)) + '\n');
+    }
+    catch (e) {
+        process.stdout.write(theme.err(`/pr failed: ${e?.message}\n`));
+    }
+}
+function colorize(diff) {
+    return diff
+        .split('\n')
+        .map((l) => l.startsWith('+') && !l.startsWith('+++')
+        ? theme.ok(l)
+        : l.startsWith('-') && !l.startsWith('---')
+            ? theme.err(l)
+            : l.startsWith('@@')
+                ? theme.hl(l)
+                : l.startsWith('diff ') || l.startsWith('index ')
+                    ? theme.dim(l)
+                    : l)
+        .join('\n');
+}