@stan-chen/simple-cli 0.2.1

package/dist/lib/git.js

@@ -0,0 +1,351 @@
+/**
+ * Git Operations using simple-git
+ * Reliable git operations leveraging the native Git binary
+ */
+import simpleGit from 'simple-git';
+/**
+ * GitManager - Wrapper around simple-git for reliable git operations
+ */
+export class GitManager {
+    git;
+    cwd;
+    constructor(config = {}) {
+        this.cwd = config.cwd || process.cwd();
+        this.git = simpleGit({
+            baseDir: this.cwd,
+            binary: 'git',
+            maxConcurrentProcesses: 6,
+            timeout: {
+                block: config.timeout || 30000,
+            },
+        });
+    }
+    /**
+     * Check if current directory is a git repository
+     */
+    async isRepo() {
+        try {
+            await this.git.revparse(['--git-dir']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Initialize a new git repository
+     */
+    async init() {
+        await this.git.init();
+    }
+    /**
+     * Get repository status
+     */
+    async status() {
+        return this.git.status();
+    }
+    /**
+     * Get current branch name
+     */
+    async currentBranch() {
+        try {
+            const result = await this.git.revparse(['--abbrev-ref', 'HEAD']);
+            return result.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get all branches
+     */
+    async branches() {
+        return this.git.branch();
+    }
+    /**
+     * Checkout a branch
+     */
+    async checkout(branch, create = false) {
+        if (create) {
+            await this.git.checkoutLocalBranch(branch);
+        }
+        else {
+            await this.git.checkout(branch);
+        }
+    }
+    /**
+     * Stage files
+     */
+    async add(files) {
+        const fileList = Array.isArray(files) ? files : [files];
+        await this.git.add(fileList);
+    }
+    /**
+     * Stage all changes
+     */
+    async addAll() {
+        await this.git.add('-A');
+    }
+    /**
+     * Commit changes
+     */
+    async commit(options) {
+        const { message, files, amend, noVerify, author } = options;
+        try {
+            const commitOptions = {};
+            if (amend) {
+                commitOptions['--amend'] = null;
+            }
+            if (noVerify) {
+                commitOptions['--no-verify'] = null;
+            }
+            if (author) {
+                commitOptions['--author'] = author;
+            }
+            if (files && files.length > 0) {
+                await this.git.add(files);
+            }
+            const result = await this.git.commit(message, files || [], commitOptions);
+            if (result.commit) {
+                return {
+                    hash: result.commit,
+                    message: message,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Commit failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Get diff
+     */
+    async diff(options = {}) {
+        const args = ['--no-color'];
+        if (options.staged) {
+            args.push('--cached');
+        }
+        if (options.from && options.to) {
+            args.push(options.from, options.to);
+        }
+        else if (options.from) {
+            args.push(options.from);
+        }
+        if (options.file) {
+            args.push('--', options.file);
+        }
+        return this.git.diff(args);
+    }
+    /**
+     * Get staged diff
+     */
+    async stagedDiff() {
+        return this.diff({ staged: true });
+    }
+    /**
+     * Get commit log
+     */
+    async log(maxCount = 20) {
+        return this.git.log({ maxCount });
+    }
+    /**
+     * Get the last commit
+     */
+    async lastCommit() {
+        try {
+            const log = await this.git.log({ maxCount: 1 });
+            if (log.latest) {
+                return {
+                    hash: log.latest.hash,
+                    message: log.latest.message,
+                    author: log.latest.author_name,
+                    date: log.latest.date,
+                };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Undo the last commit (soft reset)
+     */
+    async undoLastCommit() {
+        try {
+            await this.git.reset(['--soft', 'HEAD~1']);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Hard reset to a commit
+     */
+    async hardReset(commit = 'HEAD') {
+        await this.git.reset(['--hard', commit]);
+    }
+    /**
+     * Stash changes
+     */
+    async stash(message) {
+        if (message) {
+            await this.git.stash(['push', '-m', message]);
+        }
+        else {
+            await this.git.stash();
+        }
+    }
+    /**
+     * Pop stash
+     */
+    async stashPop() {
+        await this.git.stash(['pop']);
+    }
+    /**
+     * Get list of tracked files
+     */
+    async trackedFiles() {
+        const result = await this.git.raw(['ls-files']);
+        return result.split('\n').filter(Boolean);
+    }
+    /**
+     * Get list of changed files (staged + unstaged)
+     */
+    async changedFiles() {
+        const status = await this.status();
+        return [
+            ...status.modified,
+            ...status.created,
+            ...status.deleted,
+            ...status.renamed.map(r => r.to),
+            ...status.not_added,
+        ];
+    }
+    /**
+     * Check if a file is ignored
+     */
+    async isIgnored(file) {
+        try {
+            await this.git.raw(['check-ignore', '-q', file]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get blame for a file
+     */
+    async blame(file) {
+        return this.git.raw(['blame', '--no-color', '-l', file]);
+    }
+    /**
+     * Show a specific commit
+     */
+    async show(commit) {
+        return this.git.show(['--no-color', '--stat', commit]);
+    }
+    /**
+     * Get the root directory of the repository
+     */
+    async rootDir() {
+        try {
+            const result = await this.git.revparse(['--show-toplevel']);
+            return result.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Pull changes from remote
+     */
+    async pull(remote = 'origin', branch) {
+        if (branch) {
+            await this.git.pull(remote, branch);
+        }
+        else {
+            await this.git.pull();
+        }
+    }
+    /**
+     * Push changes to remote
+     */
+    async push(remote = 'origin', branch, options) {
+        const args = [];
+        if (options?.setUpstream) {
+            args.push('-u');
+        }
+        args.push(remote);
+        if (branch) {
+            args.push(branch);
+        }
+        await this.git.push(args);
+    }
+    /**
+     * Create a new branch from current HEAD
+     */
+    async createBranch(name) {
+        await this.git.checkoutLocalBranch(name);
+    }
+    /**
+     * Delete a branch
+     */
+    async deleteBranch(name, force = false) {
+        await this.git.deleteLocalBranch(name, force);
+    }
+    /**
+     * Merge a branch into current branch
+     */
+    async merge(branch) {
+        await this.git.merge([branch]);
+    }
+    /**
+     * Get the raw simple-git instance for advanced operations
+     */
+    raw() {
+        return this.git;
+    }
+}
+// Singleton instance
+let gitManager = null;
+/**
+ * Get or create a GitManager instance
+ */
+export function getGitManager(config) {
+    if (!gitManager || config) {
+        gitManager = new GitManager(config);
+    }
+    return gitManager;
+}
+/**
+ * Generate AI commit message from diff
+ */
+export async function generateCommitMessage(diff, generateFn, context) {
+    const prompt = `Generate a concise git commit message for these changes.
+
+Guidelines:
+- Start with a type: feat, fix, refactor, docs, test, chore
+- Keep the first line under 72 characters
+- Focus on the "why" not the "what"
+- Use imperative mood ("add" not "added")
+
+${context ? `Context: ${context}\n` : ''}
+Diff:
+\`\`\`
+${diff.slice(0, 4000)}${diff.length > 4000 ? '\n... (truncated)' : ''}
+\`\`\`
+
+Respond with ONLY the commit message, no explanation.`;
+    const message = await generateFn(prompt);
+    // Clean up the response
+    return message
+        .trim()
+        .replace(/^["']|["']$/g, '') // Remove quotes
+        .replace(/^commit:?\s*/i, '') // Remove "commit:" prefix
+        .split('\n')[0]; // Take only first line
+}

package/dist/lib/ui.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Terminal UI using Clack
+ * Modern, clean terminal prompts and spinners
+ */
+import * as p from '@clack/prompts';
+export { p as prompts };
+/**
+ * UI Theme colors
+ */
+export declare const theme: {
+    primary: import("picocolors/types").Formatter;
+    success: import("picocolors/types").Formatter;
+    warning: import("picocolors/types").Formatter;
+    error: import("picocolors/types").Formatter;
+    muted: import("picocolors/types").Formatter;
+    highlight: import("picocolors/types").Formatter;
+    code: import("picocolors/types").Formatter;
+};
+/**
+ * Display intro banner
+ */
+export declare function intro(message: string): void;
+/**
+ * Display outro message
+ */
+export declare function outro(message: string): void;
+/**
+ * Display a note
+ */
+export declare function note(message: string, title?: string): void;
+/**
+ * Display a log message
+ */
+export declare function log(message: string): void;
+/**
+ * Display an info message
+ */
+export declare function info(message: string): void;
+/**
+ * Display a success message
+ */
+export declare function success(message: string): void;
+/**
+ * Display a warning message
+ */
+export declare function warning(message: string): void;
+/**
+ * Display an error message
+ */
+export declare function error(message: string): void;
+/**
+ * Display a step message
+ */
+export declare function step(message: string): void;
+/**
+ * Show a spinner while executing an async operation
+ */
+export declare function spin<T>(message: string, fn: () => Promise<T>): Promise<T>;
+/**
+ * Prompt for text input
+ */
+export declare function text(options: {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    validate?: (value: string) => string | undefined;
+}): Promise<string | symbol>;
+/**
+ * Prompt for password input
+ */
+export declare function password(options: {
+    message: string;
+    validate?: (value: string) => string | undefined;
+}): Promise<string | symbol>;
+/**
+ * Prompt for confirmation
+ */
+export declare function confirm(options: {
+    message: string;
+    initialValue?: boolean;
+}): Promise<boolean | symbol>;
+/**
+ * Prompt for single selection
+ */
+export declare function select<T extends string>(options: {
+    message: string;
+    options: Array<{
+        value: T;
+        label: string;
+        hint?: string;
+    }>;
+    initialValue?: T;
+}): Promise<T | symbol>;
+/**
+ * Prompt for multi-selection
+ */
+export declare function multiselect<T extends string>(options: {
+    message: string;
+    options: Array<{
+        value: T;
+        label: string;
+        hint?: string;
+    }>;
+    initialValues?: T[];
+    required?: boolean;
+}): Promise<T[] | symbol>;
+/**
+ * Group related prompts together
+ */
+export declare function group<T extends Record<string, unknown>>(prompts: Record<keyof T, () => Promise<unknown>>, options?: {
+    onCancel?: () => void;
+}): Promise<T>;
+/**
+ * Check if user cancelled
+ */
+export declare function isCancel(value: unknown): value is symbol;
+/**
+ * Cancel and exit
+ */
+export declare function cancel(message?: string): void;
+/**
+ * Display a diff with syntax highlighting
+ */
+export declare function showDiff(diffText: string): void;
+/**
+ * Display a code block
+ */
+export declare function showCode(code: string, language?: string): void;
+/**
+ * Display a thinking/reasoning block
+ */
+export declare function showThought(thought: string): void;
+/**
+ * Display a tool invocation
+ */
+export declare function showToolCall(name: string, args: Record<string, unknown>): void;
+/**
+ * Display a tool result
+ */
+export declare function showToolResult(result: string, truncate?: number): void;
+/**
+ * Display file status indicators
+ */
+export declare function showFileStatus(files: Array<{
+    path: string;
+    status: 'added' | 'modified' | 'deleted' | 'readonly';
+}>): void;
+/**
+ * Display token count
+ */
+export declare function showTokens(count: number, max?: number): void;
+/**
+ * Create a task list for progress tracking
+ */
+export declare function tasks(): {
+    add: (name: string, status?: 'pending' | 'running' | 'done' | 'error') => void;
+    update: (name: string, status: 'pending' | 'running' | 'done' | 'error') => void;
+    render: () => void;
+};