atoo-studio 0.0.1 → 0.0.2

package/dist/src/services/fs-browser.js

@@ -0,0 +1,98 @@
+import fs from 'fs';
+import fsp from 'fs/promises';
+import path from 'path';
+const SKIP_NAMES = new Set(['.git', '.atoo-studio', 'node_modules', '.next', '.nuxt', 'dist', 'build', '__pycache__', '.venv', 'venv', '.cache', '.parcel-cache', 'coverage', '.svn', '.hg']);
+const MAX_DEPTH = 8;
+const MAX_ENTRIES = 2000;
+export async function getFileTree(dirPath, depth = 0, showHidden = false, maxDepth = MAX_DEPTH) {
+    if (depth > maxDepth)
+        return [];
+    let entries;
+    try {
+        entries = await fsp.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const result = [];
+    let count = 0;
+    // Sort: dirs first, then files, alphabetically
+    entries.sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory())
+            return a.isDirectory() ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+    for (const entry of entries) {
+        if (count >= MAX_ENTRIES)
+            break;
+        if (entry.isDirectory()) {
+            if (!showHidden && SKIP_NAMES.has(entry.name))
+                continue;
+            if (depth >= maxDepth) {
+                // At max depth, include dir without loading children
+                result.push({ name: entry.name, type: 'dir' });
+            }
+            else {
+                const children = await getFileTree(path.join(dirPath, entry.name), depth + 1, showHidden, maxDepth);
+                result.push({ name: entry.name, type: 'dir', children });
+            }
+        }
+        else if (entry.isFile() || entry.isSymbolicLink()) {
+            if (!showHidden && SKIP_NAMES.has(entry.name))
+                continue;
+            result.push({ name: entry.name, type: 'file' });
+        }
+        count++;
+    }
+    return result;
+}
+const EXT_LANG_MAP = {
+    ts: 'typescript', tsx: 'typescript', js: 'javascript', jsx: 'javascript',
+    py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', cpp: 'cpp', h: 'c',
+    cs: 'csharp', rb: 'ruby', php: 'php', swift: 'swift', kt: 'kotlin',
+    json: 'json', yaml: 'yaml', yml: 'yaml', toml: 'toml', xml: 'xml',
+    md: 'markdown', html: 'html', css: 'css', scss: 'scss', less: 'less',
+    sql: 'sql', sh: 'shell', bash: 'shell', zsh: 'shell',
+    dockerfile: 'dockerfile', makefile: 'makefile',
+    astro: 'html', vue: 'html', svelte: 'html',
+};
+const BINARY_EXTENSIONS = new Set([
+    'png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'webp', 'tiff', 'tif', 'psd', 'avif',
+    'mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a', 'wma',
+    'mp4', 'avi', 'mkv', 'mov', 'wmv', 'flv', 'webm',
+    'zip', 'tar', 'gz', 'bz2', '7z', 'rar', 'xz', 'zst',
+    'exe', 'dll', 'so', 'dylib', 'bin', 'msi', 'deb', 'rpm', 'appimage',
+    'woff', 'woff2', 'ttf', 'otf', 'eot',
+    'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx',
+    'class', 'pyc', 'pyo', 'o', 'obj', 'wasm', 'a', 'lib',
+    'sqlite', 'db', 'sqlite3',
+]);
+export function isBinaryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    if (BINARY_EXTENSIONS.has(ext))
+        return true;
+    // Check first 8KB for null bytes
+    try {
+        const fd = fs.openSync(filePath, 'r');
+        const buf = Buffer.alloc(8192);
+        const bytesRead = fs.readSync(fd, buf, 0, 8192, 0);
+        fs.closeSync(fd);
+        for (let i = 0; i < bytesRead; i++) {
+            if (buf[i] === 0)
+                return true;
+        }
+    }
+    catch { }
+    return false;
+}
+export function readFileContent(filePath) {
+    const ext = path.extname(filePath).toLowerCase().replace('.', '');
+    const basename = path.basename(filePath).toLowerCase();
+    const lang = EXT_LANG_MAP[ext] || EXT_LANG_MAP[basename] || 'plaintext';
+    if (isBinaryFile(filePath)) {
+        const stat = fs.statSync(filePath);
+        return { content: '', lang, isBinary: true, size: stat.size };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return { content, lang };
+}

package/dist/src/services/git-ops.d.ts

@@ -0,0 +1,78 @@
+export declare function gitInit(cwd: string): Promise<void>;
+export declare function gitClone(url: string, dest: string): Promise<void>;
+export declare function gitStatus(cwd: string): Promise<{
+    status: string;
+    file: string;
+    staged: boolean;
+    indexStatus: string;
+    workTreeStatus: string;
+    oldPath: string | undefined;
+}[]>;
+export declare function gitLog(cwd: string, branch?: string, count?: number): Promise<{
+    hash: string;
+    fullHash: string;
+    msg: string;
+    fullMessage: string;
+    author: string;
+    date: string;
+    files: never[];
+    merge: boolean;
+}[]>;
+export declare function gitCommitFiles(cwd: string, hash: string): Promise<({
+    path: string;
+    status: string;
+    oldPath: string;
+    additions: number;
+    deletions: number;
+} | {
+    path: string;
+    status: string;
+    additions: number;
+    deletions: number;
+    oldPath?: undefined;
+})[]>;
+export declare function gitBranches(cwd: string): Promise<{
+    branches: string[];
+    currentBranch: string;
+}>;
+export declare function gitCheckout(cwd: string, branch: string): Promise<void>;
+export declare function gitCommit(cwd: string, message: string): Promise<void>;
+export declare function gitPush(cwd: string): Promise<void>;
+export declare function gitStash(cwd: string): Promise<void>;
+export declare function gitStashList(cwd: string): Promise<{
+    id: string;
+    name: string;
+}[]>;
+export declare function gitStashApply(cwd: string, id: string): Promise<void>;
+export declare function gitStashDrop(cwd: string, id: string): Promise<void>;
+export declare function gitCreateBranch(cwd: string, name: string): Promise<void>;
+export declare function gitFetch(cwd: string): Promise<void>;
+export declare function gitRemotes(cwd: string): Promise<{
+    name: string;
+    url: string;
+    type: string;
+}[]>;
+export declare function gitAddRemote(cwd: string, name: string, url: string): Promise<void>;
+export declare function gitRemoveRemote(cwd: string, name: string): Promise<void>;
+export declare function gitEditRemote(cwd: string, name: string, url: string): Promise<void>;
+export declare function gitDiff(cwd: string, file?: string): Promise<string>;
+export declare function gitRevert(cwd: string, file?: string): Promise<void>;
+export declare function gitUnstageFile(cwd: string, file: string): Promise<void>;
+export declare function gitStageFile(cwd: string, file: string): Promise<void>;
+export declare function gitShowFile(cwd: string, file: string, ref?: string): Promise<string>;
+export declare function gitBlame(cwd: string, file: string): Promise<string>;
+export declare function gitFileLog(cwd: string, file: string): Promise<{
+    hash: string;
+    author: string;
+    date: string;
+    msg: string;
+}[]>;
+export declare function gitWorktreeList(cwd: string): Promise<{
+    path: string;
+    head: string;
+    branch: string;
+    bare?: boolean;
+}[]>;
+export declare function gitWorktreeAdd(cwd: string, path: string, branch?: string, newBranch?: boolean): Promise<void>;
+export declare function gitWorktreeRemove(cwd: string, worktreePath: string): Promise<void>;
+export declare function gitBranchDelete(cwd: string, branch: string): Promise<void>;

package/dist/src/services/git-ops.js

@@ -0,0 +1,288 @@
+import { execFile } from 'child_process';
+import path from 'path';
+const TIMEOUT = 15000;
+function git(args, cwd) {
+    return new Promise((resolve, reject) => {
+        execFile('git', args, { cwd, timeout: TIMEOUT, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+            if (err) {
+                reject(new Error(stderr?.trim() || err.message));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+export async function gitInit(cwd) {
+    await git(['init'], cwd);
+}
+export async function gitClone(url, dest) {
+    const { execFile } = await import('child_process');
+    return new Promise((resolve, reject) => {
+        execFile('git', ['clone', url, dest], { timeout: 120000, maxBuffer: 10 * 1024 * 1024 }, (err, _stdout, stderr) => {
+            if (err)
+                reject(new Error(stderr?.trim() || err.message));
+            else
+                resolve();
+        });
+    });
+}
+export async function gitStatus(cwd) {
+    const output = await git(['status', '--porcelain', '-uall', '-M'], cwd);
+    const entries = output.split('\n').filter(Boolean).map(line => {
+        const x = line[0]; // index (staged) status
+        const y = line[1]; // working tree status
+        const rest = line.substring(3);
+        // Handle renames: porcelain format "R  old_path -> new_path"
+        let file = rest;
+        let oldPath;
+        if (x === 'R' || y === 'R') {
+            const arrowIdx = rest.indexOf(' -> ');
+            if (arrowIdx >= 0) {
+                oldPath = rest.substring(0, arrowIdx);
+                file = rest.substring(arrowIdx + 4);
+            }
+        }
+        let status = (x + y).trim() || '?';
+        const staged = x !== ' ' && x !== '?' && x !== '!';
+        return { status, file, staged, indexStatus: x, workTreeStatus: y, oldPath };
+    });
+    // Detect unstaged renames: pair D (deleted) + ?? (untracked) by comparing file content hashes
+    // Skip when there are too many entries — the O(n*m) hash comparisons would be very slow
+    const deleted = entries.filter(e => e.status === 'D' || e.status === ' D');
+    const untracked = entries.filter(e => e.status === '??');
+    if (deleted.length > 0 && untracked.length > 0 && deleted.length + untracked.length <= 200) {
+        try {
+            // Get hashes for deleted files (from HEAD) and untracked files (from working tree)
+            const deletedHashes = new Map();
+            for (const d of deleted) {
+                try {
+                    const hash = (await git(['hash-object', '--stdin-path', d.file], cwd)).trim();
+                    // Actually use show to get the blob hash from HEAD
+                    const h = (await git(['rev-parse', `HEAD:${d.file}`], cwd)).trim();
+                    deletedHashes.set(h, d.file);
+                }
+                catch { }
+            }
+            const matched = new Set();
+            for (const u of untracked) {
+                try {
+                    const h = (await git(['hash-object', path.join(cwd, u.file)], cwd)).trim();
+                    const oldFile = deletedHashes.get(h);
+                    if (oldFile) {
+                        // Found a match — convert to rename
+                        u.status = 'R';
+                        u.indexStatus = 'R';
+                        u.oldPath = oldFile;
+                        u.staged = false;
+                        matched.add(oldFile);
+                        deletedHashes.delete(h);
+                    }
+                }
+                catch { }
+            }
+            // Remove matched deleted entries
+            if (matched.size > 0) {
+                return entries.filter(e => !(matched.has(e.file) && (e.status === 'D' || e.status === ' D')));
+            }
+        }
+        catch { }
+    }
+    return entries;
+}
+export async function gitLog(cwd, branch, count = 30) {
+    const SEP = '---GIT-LOG-SEP---';
+    const args = ['log', `--format=${SEP}%n%H%n%h%n%an%n%ar%n%s%n%B`, '-n', String(count)];
+    if (branch)
+        args.push(branch);
+    const output = await git(args, cwd);
+    const entries = output.split(SEP).filter(e => e.trim());
+    return entries.map(entry => {
+        const lines = entry.trim().split('\n');
+        const fullHash = lines[0] || '';
+        const hash = lines[1] || '';
+        const author = lines[2] || '';
+        const date = lines[3] || '';
+        const msg = lines[4] || '';
+        const fullMessage = lines.slice(5).join('\n').trim() || msg;
+        const isMerge = msg.toLowerCase().startsWith('merge');
+        return { hash, fullHash, msg, fullMessage, author, date, files: [], merge: isMerge };
+    });
+}
+export async function gitCommitFiles(cwd, hash) {
+    const output = await git(['diff-tree', '--no-commit-id', '-r', '--name-status', '-M', hash], cwd);
+    return output.trim().split('\n').filter(Boolean).map(line => {
+        const parts = line.split('\t');
+        const statusChar = parts[0]?.[0] || 'M';
+        const statusMap = { A: 'A', M: 'M', D: 'D', R: 'R', C: 'C' };
+        const status = statusMap[statusChar] || 'M';
+        // Renames/copies have format: R100\told_path\tnew_path
+        if ((statusChar === 'R' || statusChar === 'C') && parts.length >= 3) {
+            return { path: parts[2], status, oldPath: parts[1], additions: 0, deletions: 0 };
+        }
+        return { path: parts[1] || '', status, additions: 0, deletions: 0 };
+    });
+}
+export async function gitBranches(cwd) {
+    const output = await git(['branch', '-a', '--no-color'], cwd);
+    const branches = [];
+    let currentBranch = '';
+    output.split('\n').filter(Boolean).forEach(line => {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('* ')) {
+            currentBranch = trimmed.substring(2);
+            branches.push(currentBranch);
+        }
+        else {
+            branches.push(trimmed);
+        }
+    });
+    // No commits yet: git branch returns nothing, but symbolic-ref shows the unborn branch
+    if (!currentBranch) {
+        try {
+            const ref = await git(['symbolic-ref', '--short', 'HEAD'], cwd);
+            currentBranch = ref.trim();
+            if (currentBranch)
+                branches.push(currentBranch);
+        }
+        catch { }
+    }
+    return { branches, currentBranch };
+}
+export async function gitCheckout(cwd, branch) {
+    await git(['checkout', branch], cwd);
+}
+export async function gitCommit(cwd, message) {
+    await git(['add', '-A'], cwd);
+    await git(['commit', '-m', message], cwd);
+}
+export async function gitPush(cwd) {
+    await git(['push'], cwd);
+}
+export async function gitStash(cwd) {
+    await git(['stash', 'push'], cwd);
+}
+export async function gitStashList(cwd) {
+    const output = await git(['stash', 'list'], cwd);
+    return output.split('\n').filter(Boolean).map((line, i) => ({
+        id: `stash@{${i}}`,
+        name: line,
+    }));
+}
+export async function gitStashApply(cwd, id) {
+    await git(['stash', 'apply', id], cwd);
+}
+export async function gitStashDrop(cwd, id) {
+    await git(['stash', 'drop', id], cwd);
+}
+export async function gitCreateBranch(cwd, name) {
+    await git(['checkout', '-b', name], cwd);
+}
+export async function gitFetch(cwd) {
+    await git(['fetch', '--all'], cwd);
+}
+export async function gitRemotes(cwd) {
+    const output = await git(['remote', '-v'], cwd);
+    const remotes = [];
+    const seen = new Set();
+    output.split('\n').filter(Boolean).forEach(line => {
+        const parts = line.split(/\s+/);
+        const name = parts[0];
+        const url = parts[1];
+        if (!seen.has(name)) {
+            seen.add(name);
+            remotes.push({ name, url, type: url.includes('@') ? 'ssh' : 'https' });
+        }
+    });
+    return remotes;
+}
+export async function gitAddRemote(cwd, name, url) {
+    await git(['remote', 'add', name, url], cwd);
+}
+export async function gitRemoveRemote(cwd, name) {
+    await git(['remote', 'remove', name], cwd);
+}
+export async function gitEditRemote(cwd, name, url) {
+    await git(['remote', 'set-url', name, url], cwd);
+}
+export async function gitDiff(cwd, file) {
+    const args = ['diff'];
+    if (file)
+        args.push('--', file);
+    return await git(args, cwd);
+}
+export async function gitRevert(cwd, file) {
+    if (file) {
+        await git(['checkout', '--', file], cwd);
+    }
+    else {
+        await git(['checkout', '.'], cwd);
+        await git(['clean', '-fd'], cwd);
+    }
+}
+export async function gitUnstageFile(cwd, file) {
+    await git(['reset', 'HEAD', '--', file], cwd);
+}
+export async function gitStageFile(cwd, file) {
+    await git(['add', file], cwd);
+}
+export async function gitShowFile(cwd, file, ref = 'HEAD') {
+    return await git(['show', `${ref}:${file}`], cwd);
+}
+export async function gitBlame(cwd, file) {
+    const output = await git(['blame', '--porcelain', file], cwd);
+    return output;
+}
+export async function gitFileLog(cwd, file) {
+    const output = await git(['log', '--format=%h|%an|%ar|%s', '-n', '20', '--follow', '--', file], cwd);
+    return output.split('\n').filter(Boolean).map(line => {
+        const [hash, author, date, ...msgParts] = line.split('|');
+        return { hash, author, date, msg: msgParts.join('|') };
+    });
+}
+export async function gitWorktreeList(cwd) {
+    const output = await git(['worktree', 'list', '--porcelain'], cwd);
+    const worktrees = [];
+    let current = {};
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            if (current.path)
+                worktrees.push(current);
+            current = { path: line.substring(9) };
+        }
+        else if (line.startsWith('HEAD ')) {
+            current.head = line.substring(5);
+        }
+        else if (line.startsWith('branch ')) {
+            current.branch = line.substring(7).replace('refs/heads/', '');
+        }
+        else if (line === 'bare') {
+            current.bare = true;
+        }
+        else if (line === 'detached') {
+            current.branch = '(detached)';
+        }
+    }
+    if (current.path)
+        worktrees.push(current);
+    return worktrees;
+}
+export async function gitWorktreeAdd(cwd, path, branch, newBranch) {
+    const args = ['worktree', 'add'];
+    if (newBranch && branch) {
+        args.push('-b', branch, path);
+    }
+    else if (branch) {
+        args.push(path, branch);
+    }
+    else {
+        args.push(path);
+    }
+    await git(args, cwd);
+}
+export async function gitWorktreeRemove(cwd, worktreePath) {
+    await git(['worktree', 'remove', worktreePath], cwd);
+}
+export async function gitBranchDelete(cwd, branch) {
+    await git(['branch', '-D', branch], cwd);
+}

package/dist/src/services/github-ops.d.ts

@@ -0,0 +1,104 @@
+export interface GitHubStatus {
+    available: boolean;
+    owner: string;
+    repo: string;
+    canWrite: boolean;
+    unavailableReason?: string;
+}
+export interface GitHubIssue {
+    number: number;
+    title: string;
+    state: string;
+    author: {
+        login: string;
+    };
+    labels: {
+        name: string;
+        color: string;
+    }[];
+    createdAt: string;
+    updatedAt: string;
+    comments: {
+        totalCount: number;
+    };
+    url: string;
+    assignees: {
+        login: string;
+    }[];
+    milestone?: {
+        title: string;
+    } | null;
+}
+export interface GitHubPull {
+    number: number;
+    title: string;
+    state: string;
+    author: {
+        login: string;
+    };
+    labels: {
+        name: string;
+        color: string;
+    }[];
+    createdAt: string;
+    updatedAt: string;
+    comments: {
+        totalCount: number;
+    };
+    url: string;
+    headRefName: string;
+    baseRefName: string;
+    isDraft: boolean;
+    mergeable: string;
+    reviewDecision: string;
+    additions: number;
+    deletions: number;
+    assignees: {
+        login: string;
+    }[];
+}
+export interface GitHubListResult<T> {
+    items: T[];
+    hasMore: boolean;
+}
+export declare function getGitHubStatus(cwd: string): Promise<GitHubStatus>;
+export declare function clearStatusCache(cwd?: string): void;
+export declare function listIssues(cwd: string, opts?: {
+    state?: string;
+    search?: string;
+    limit?: number;
+    endCursor?: string;
+}): Promise<GitHubListResult<GitHubIssue>>;
+export declare function listPulls(cwd: string, opts?: {
+    state?: string;
+    search?: string;
+    limit?: number;
+}): Promise<GitHubListResult<GitHubPull>>;
+export interface GitHubComment {
+    author: {
+        login: string;
+    };
+    body: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface GitHubIssueDetail extends GitHubIssue {
+    body: string;
+    comments_list: GitHubComment[];
+}
+export interface GitHubPullDetail extends GitHubPull {
+    body: string;
+    comments_list: GitHubComment[];
+}
+export declare function getIssueDetail(cwd: string, number: number): Promise<GitHubIssueDetail>;
+export declare function getPullDetail(cwd: string, number: number): Promise<GitHubPullDetail>;
+export declare function updateIssueState(cwd: string, number: number, action: 'close' | 'reopen'): Promise<void>;
+export declare function updatePullState(cwd: string, number: number, action: 'close' | 'reopen'): Promise<void>;
+export declare function createPullRequest(cwd: string, opts: {
+    title: string;
+    body?: string;
+    base?: string;
+}): Promise<{
+    number: number;
+    url: string;
+}>;