@codecora/cli 0.0.3

package/dist/config/storage.js

@@ -0,0 +1,166 @@
+/**
+ * Local Configuration Storage
+ *
+ * Manages ~/.codecora/ directory for storing:
+ * - config.yml: User configuration
+ * - auth.json: Encrypted auth token (in production)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { existsSync } from 'node:fs';
+/**
+ * CORA CLI config directory
+ */
+export const CORA_CONFIG_DIR = path.join(os.homedir(), '.codecora');
+/**
+ * Config file path
+ */
+export const CORA_CONFIG_FILE = path.join(CORA_CONFIG_DIR, 'config.json');
+/**
+ * Auth file path
+ */
+export const CORA_AUTH_FILE = path.join(CORA_CONFIG_DIR, 'auth.json');
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    auth: {
+        serverUrl: 'https://codecora.dev',
+        sessionToken: '',
+        expiresAt: '',
+    },
+    preferences: {
+        autoReview: true,
+        blockOnCritical: true,
+        blockOnMajor: false,
+    },
+};
+/**
+ * Ensure config directory exists
+ */
+export function ensureConfigDir() {
+    if (!existsSync(CORA_CONFIG_DIR)) {
+        fs.mkdirSync(CORA_CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+/**
+ * Read local configuration
+ *
+ * Returns merged config from files and defaults.
+ */
+export async function getLocalConfig() {
+    const config = { ...DEFAULT_CONFIG };
+    // Read auth file
+    if (existsSync(CORA_AUTH_FILE)) {
+        try {
+            const authData = fs.readFileSync(CORA_AUTH_FILE, 'utf-8');
+            const auth = JSON.parse(authData);
+            config.auth = { ...config.auth, ...auth };
+        }
+        catch (error) {
+            // If auth file is corrupted, ignore it
+            console.warn(`Warning: Failed to read auth file: ${error}`);
+        }
+    }
+    // Read config file
+    if (existsSync(CORA_CONFIG_FILE)) {
+        try {
+            const configData = fs.readFileSync(CORA_CONFIG_FILE, 'utf-8');
+            const userConfig = JSON.parse(configData);
+            Object.assign(config, userConfig);
+        }
+        catch (error) {
+            console.warn(`Warning: Failed to read config file: ${error}`);
+        }
+    }
+    return config;
+}
+/**
+ * Write local configuration
+ */
+export async function setLocalConfig(config) {
+    ensureConfigDir();
+    // Split auth and user config
+    const auth = config.auth;
+    const userConfig = { ...config };
+    delete userConfig.auth;
+    // Write auth file
+    if (auth) {
+        fs.writeFileSync(CORA_AUTH_FILE, JSON.stringify(auth, null, 2), { mode: 0o600 });
+    }
+    // Write config file
+    if (Object.keys(userConfig).length > 0) {
+        fs.writeFileSync(CORA_CONFIG_FILE, JSON.stringify(userConfig, null, 2), { mode: 0o644 });
+    }
+}
+/**
+ * Update specific config values
+ */
+export async function updateLocalConfig(updates) {
+    const config = await getLocalConfig();
+    const merged = deepMerge(config, updates);
+    await setLocalConfig(merged);
+}
+/**
+ * Set auth token
+ */
+export async function setAuthToken(sessionToken, serverUrl, userId, email, expiresAt) {
+    await updateLocalConfig({
+        auth: {
+            sessionToken,
+            serverUrl,
+            expiresAt,
+        },
+        user: {
+            id: userId,
+            email,
+        },
+    });
+}
+/**
+ * Clear auth token
+ */
+export async function clearAuthToken() {
+    if (existsSync(CORA_AUTH_FILE)) {
+        fs.unlinkSync(CORA_AUTH_FILE);
+    }
+}
+/**
+ * Check if user is authenticated
+ */
+export async function isAuthenticated() {
+    const config = await getLocalConfig();
+    return !!config.auth?.sessionToken;
+}
+/**
+ * Get auth token
+ */
+export async function getAuthToken() {
+    const config = await getLocalConfig();
+    return config.auth?.sessionToken;
+}
+/**
+ * Deep merge objects
+ */
+function deepMerge(target, source) {
+    const output = { ...target };
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const sourceValue = source[key];
+            const targetValue = output[key];
+            if (sourceValue &&
+                typeof sourceValue === 'object' &&
+                !Array.isArray(sourceValue) &&
+                targetValue &&
+                typeof targetValue === 'object' &&
+                !Array.isArray(targetValue)) {
+                output[key] = deepMerge(targetValue, sourceValue);
+            }
+            else {
+                output[key] = sourceValue;
+            }
+        }
+    }
+    return output;
+}

package/dist/git/diff.js

@@ -0,0 +1,162 @@
+/**
+ * Git Diff Utilities for CLI
+ *
+ * Functions to capture git diffs in various formats.
+ * Uses safe execFile to prevent command injection vulnerabilities.
+ */
+import { existsSync } from 'node:fs';
+import * as path from 'node:path';
+import { execFileSafe } from '../utils/exec.js';
+/**
+ * Check if current directory is a git repository
+ */
+export function isGitRepo(cwd = process.cwd()) {
+    return existsSync(path.join(cwd, '.git'));
+}
+/**
+ * Get git diff for staged changes
+ *
+ * Returns diff of files that are staged for commit.
+ */
+export function getStagedDiff(cwd = process.cwd()) {
+    const result = execFileSafe('git', ['diff', '--cached'], { cwd });
+    if (result.status !== 0) {
+        throw new Error(`Failed to get staged diff: ${result.stderr || result.error?.message}`);
+    }
+    return result.stdout;
+}
+/**
+ * Get git diff for unstaged changes
+ *
+ * Returns diff of files that are modified but not staged.
+ */
+export function getUnstagedDiff(cwd = process.cwd()) {
+    const result = execFileSafe('git', ['diff'], { cwd });
+    if (result.status !== 0) {
+        throw new Error(`Failed to get unstaged diff: ${result.stderr || result.error?.message}`);
+    }
+    return result.stdout;
+}
+/**
+ * Get git diff for specific files
+ *
+ * Returns diff of specified files (staged or unstaged).
+ */
+export function getFilesDiff(files, staged = true, cwd = process.cwd()) {
+    const args = ['diff', ...(staged ? ['--cached'] : []), '--', ...files];
+    const result = execFileSafe('git', args, { cwd });
+    if (result.status !== 0) {
+        throw new Error(`Failed to get files diff: ${result.stderr || result.error?.message}`);
+    }
+    return result.stdout;
+}
+/**
+ * Get combined diff (staged + unstaged)
+ *
+ * Returns all changes including both staged and unstaged.
+ */
+export function getCombinedDiff(cwd = process.cwd()) {
+    // Get staged diff
+    const staged = getStagedDiff(cwd);
+    // Get unstaged diff
+    const unstaged = getUnstagedDiff(cwd);
+    // Combine them
+    if (staged && unstaged) {
+        return `${staged}\n${unstaged}`;
+    }
+    else if (staged) {
+        return staged;
+    }
+    else {
+        return unstaged;
+    }
+}
+/**
+ * Get repository information
+ */
+export function getRepoInfo(cwd = process.cwd()) {
+    // Get remote URL
+    const remoteResult = execFileSafe('git', ['config', '--get', 'remote.origin.url'], { cwd });
+    if (remoteResult.status !== 0 || !remoteResult.stdout) {
+        // If we can't get repo info, return defaults
+        return {
+            owner: 'unknown',
+            repo: 'unknown',
+            branch: 'main',
+        };
+    }
+    const remoteUrl = remoteResult.stdout.trim();
+    // Parse owner/repo from URL
+    // Supports: git@github.com:owner/repo.git
+    //          https://github.com/owner/repo.git
+    let owner = '';
+    let repo = '';
+    const sshMatch = remoteUrl.match(/git@github\.com:([^/]+)\/(.+?)\.git/);
+    const httpsMatch = remoteUrl.match(/github\.com[\/:]([^/]+)\/(.+?)(\.git|$)/);
+    if (sshMatch && sshMatch[1] && sshMatch[2]) {
+        owner = sshMatch[1];
+        repo = sshMatch[2];
+    }
+    else if (httpsMatch && httpsMatch[1] && httpsMatch[2]) {
+        owner = httpsMatch[1];
+        repo = httpsMatch[2];
+    }
+    // Get current branch
+    const branchResult = execFileSafe('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+    const branch = branchResult.status === 0 ? branchResult.stdout.trim() : 'main';
+    return { owner, repo, branch };
+}
+/**
+ * Get list of changed files
+ *
+ * Returns files that have been modified (staged or unstaged).
+ */
+export function getChangedFiles(cwd = process.cwd()) {
+    const files = [];
+    // Get staged files
+    const stagedResult = execFileSafe('git', ['diff', '--cached', '--name-only'], { cwd });
+    if (stagedResult.status === 0) {
+        files.push(...stagedResult.stdout.split('\n').filter(Boolean));
+    }
+    // Get unstaged files
+    const unstagedResult = execFileSafe('git', ['diff', '--name-only'], { cwd });
+    if (unstagedResult.status === 0) {
+        files.push(...unstagedResult.stdout.split('\n').filter(Boolean));
+    }
+    // Return unique files
+    return Array.from(new Set(files));
+}
+/**
+ * Validate diff size
+ *
+ * Checks if diff exceeds maximum size limit.
+ */
+export function validateDiffSize(diff, maxSize = 10 * 1024 * 1024 // 10MB default
+) {
+    const size = Buffer.byteLength(diff, 'utf-8');
+    if (size > maxSize) {
+        return {
+            valid: false,
+            size,
+            error: `Diff size (${(size / 1024 / 1024).toFixed(2)}MB) exceeds maximum (${(maxSize / 1024 / 1024).toFixed(2)}MB)`,
+        };
+    }
+    return { valid: true, size };
+}
+/**
+ * Get diff for review
+ *
+ * Main function to get diff based on options.
+ */
+export function getReviewDiff(options) {
+    const { staged = true, files, cwd = process.cwd() } = options;
+    if (files && files.length > 0) {
+        return getFilesDiff(files, staged, cwd);
+    }
+    else if (staged) {
+        return getStagedDiff(cwd);
+    }
+    else {
+        return getUnstagedDiff(cwd);
+    }
+}

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * CORA CLI Package
+ *
+ * AI-powered code review for git commits.
+ */
+export * from './api/types.js';
+export * from './api/client.js';
+export * from './config/storage.js';
+export * from './git/diff.js';
+export * from './utils/exec.js';
+export * from './commands/index.js';
+// Test change

package/dist/utils/exec.js

@@ -0,0 +1,76 @@
+/**
+ * Safe process execution utilities
+ *
+ * Uses execFile instead of exec to prevent command injection vulnerabilities.
+ * Handles Windows compatibility and provides proper error handling.
+ */
+import { execFileSync } from 'node:child_process';
+/**
+ * Execute command synchronously with safety guarantees
+ *
+ * Uses execFile which doesn't go through shell, preventing command injection.
+ *
+ * @param command - Command to execute
+ * @param args - Command arguments (will be safely escaped)
+ * @param options - Child process options
+ * @returns Execution result with stdout, stderr, and status
+ */
+export function execFileSafe(command, args = [], options = {}) {
+    const { cwd = process.cwd(), encoding = 'utf-8' } = options;
+    try {
+        const stdout = execFileSync(command, args, {
+            cwd,
+            encoding: encoding,
+        });
+        return {
+            stdout,
+            stderr: '',
+            status: 0,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            stdout: err.stdout || '',
+            stderr: err.stderr || '',
+            status: err.status ?? null,
+            error: error,
+        };
+    }
+}
+/**
+ * Execute command asynchronously with safety guarantees
+ *
+ * Uses execFile which doesn't go through shell, preventing command injection.
+ *
+ * @param command - Command to execute
+ * @param args - Command arguments (will be safely escaped)
+ * @param options - Child process options
+ * @returns Execution result with stdout, stderr, and status
+ */
+export async function execFileSafeAsync(command, args = [], options = {}) {
+    const { cwd = process.cwd(), encoding = 'utf-8' } = options;
+    try {
+        const { execFile: execFileAsync } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const asyncExecFile = promisify(execFileAsync);
+        const { stdout, stderr } = await asyncExecFile(command, args, {
+            cwd,
+            encoding: encoding,
+        });
+        return {
+            stdout,
+            stderr,
+            status: 0,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            stdout: err.stdout || '',
+            stderr: err.stderr || '',
+            status: err.status ?? null,
+            error: error,
+        };
+    }
+}

package/dist/version.js

@@ -0,0 +1 @@
+export const VERSION = '0.0.3';

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@codecora/cli",
+  "version": "0.0.3",
+  "type": "module",
+  "description": "CORA CLI - AI code review before commit",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./api": {
+      "types": "./dist/api/types.d.ts",
+      "import": "./dist/api/types.js"
+    },
+    "./api/client": {
+      "types": "./dist/api/client.d.ts",
+      "import": "./dist/api/client.js"
+    },
+    "./config/storage": {
+      "types": "./dist/config/storage.d.ts",
+      "import": "./dist/config/storage.js"
+    },
+    "./git/diff": {
+      "types": "./dist/git/diff.d.ts",
+      "import": "./dist/git/diff.js"
+    },
+    "./utils/exec": {
+      "types": "./dist/utils/exec.d.ts",
+      "import": "./dist/utils/exec.js"
+    }
+  },
+  "bin": {
+    "cora": "./bin/cora.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:binary": "tsc && pkg . --targets node18-macos-x64,node18-macos-arm64,node18-linux-x64,node18-win-x64 --output ./binaries/cora",
+    "dev": "tsc --watch",
+    "check-types": "tsc --noEmit",
+    "test": "vitest",
+    "test:unit": "vitest tests/unit"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ora": "^8.1.0",
+    "cli-table3": "^0.6.5",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.0",
+    "pkg": "^5.8.1"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "bun": ">=1.0.0"
+  },
+  "keywords": [
+    "cli",
+    "code-review",
+    "ai",
+    "git",
+    "pre-commit"
+  ],
+  "pkg": {
+    "scripts": [
+      "dist/**/*.js"
+    ],
+    "assets": [
+      "package.json"
+    ],
+    "targets": [
+      "node18-macos-x64",
+      "node18-macos-arm64",
+      "node18-linux-x64",
+      "node18-win-x64"
+    ],
+    "outputPath": "./binaries"
+  },
+  "author": "CORA",
+  "license": "MIT"
+}