@stan-chen/simple-cli 0.2.3 → 0.2.4

package/dist/lib/git.js

@@ -1,356 +0,0 @@
-/**
- * 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']);
-            const trimmed = result.trim();
-            // Ensure Windows paths use backslashes for tests that compare exact strings
-            if (process.platform === 'win32') {
-                return trimmed.replace(/\//g, '\\');
-            }
-            return trimmed;
-        }
-        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/shim.d.ts

@@ -1,4 +0,0 @@
-/**
- * Invoke a simple-cli tool with arguments
- */
-export declare function invoke(tool: string, args?: Record<string, any>): Promise<any>;

package/dist/lib/shim.js

@@ -1,30 +0,0 @@
-/**
- * OpenClaw RPC Shim: allow scripts to call simple-cli tools
- */
-import { execSync } from 'child_process';
-/**
- * Invoke a simple-cli tool with arguments
- */
-export async function invoke(tool, args = {}) {
-    // Determine path to simple-cli. We assume it's in the same project or installed.
-    // In production, we'd use the global 'simple' command.
-    const isWindows = process.platform === 'win32';
-    const cliCmd = 'simple'; // Or local path to dist/cli.js
-    try {
-        const cmd = `${cliCmd} --invoke-json "${tool}" "${JSON.stringify(args).replace(/"/g, '\\"')}"`;
-        const output = execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
-        try {
-            return JSON.parse(output.trim());
-        }
-        catch {
-            return output.trim();
-        }
-    }
-    catch (error) {
-        throw new Error(`Tool invocation failed: ${error.stderr || error.message}`);
-    }
-}
-// Global attachment for 'node.invoke' style parity
-if (typeof global.invoke === 'undefined') {
-    global.invoke = invoke;
-}

package/dist/lib/ui.d.ts

@@ -1,159 +0,0 @@
-/**
- * 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;
-};