fix: fix Git operations reliability and improve CLI configuration (#4)

* fix: improve Git command execution and validation

Ensure stdout is properly captured by setting stdio to pipe mode and add validation for Git operations to prevent empty hash errors.

* fix: improve package info retrieval and CLI configuration

Optimize package.json lookup for CommonJS environments and configure Commander.js with proper program name, description and version.

* chore: remove execa dependency

Replace execa with native Node.js child_process module for better compatibility and reduced dependencies.

* chore: add CJS format to build configuration alongside ESM

Author: kangju2000

package.json

@@ -16,7 +16,7 @@
   "files": ["dist"],
   "type": "module",
   "bin": {
-    "git-intent": "./dist/index.js"
+    "git-intent": "./dist/index.cjs"
   },
   "publishConfig": {
     "access": "public",
@@ -29,9 +29,9 @@
     "format": "biome format",
     "format:fix": "biome format --write",
     "pkg:build": "pnpm pkg:build:macos && pnpm pkg:build:linux && pnpm pkg:build:win",
-    "pkg:build:macos": "pkg . -t node18-macos-arm64 -o build/git-intent-macos",
-    "pkg:build:linux": "pkg . -t node18-linux-x64 -o build/git-intent-linux",
-    "pkg:build:win": "pkg . -t node18-win-x64 -o build/git-intent-win.exe",
+    "pkg:build:macos": "pkg . --no-bytecode -t node18-macos-arm64 -o build/git-intent-macos",
+    "pkg:build:linux": "pkg . --no-bytecode -t node18-linux-x64 -o build/git-intent-linux",
+    "pkg:build:win": "pkg . --no-bytecode -t node18-win-x64 -o build/git-intent-win.exe",
     "test": "vitest",
     "test:ui": "vitest --ui"
   },
@@ -42,7 +42,6 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "commander": "^13.1.0",
-    "execa": "^5.1.1",
     "external-editor": "^3.1.0",
     "fs-extra": "^11.3.0",
     "nanoid": "^3.3.7",

pnpm-lock.yaml

@@ -1,12 +1,18 @@
 #!/usr/bin/env node
 import { program } from 'commander';
 import * as command from './commands/index.js';
+import { getPackageInfo } from './utils/get-package-info.js';
 import { storage } from './utils/storage.js';
 
 (async () => {
   await storage.initializeRefs();
 
+  const { version, description } = getPackageInfo();
+
   program
+    .name('git-intent')
+    .description(description)
+    .version(version)
     .addCommand(command.add)
     .addCommand(command.list)
     .addCommand(command.start)

src/index.ts

@@ -1,13 +1,31 @@
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import fs from 'fs-extra';
 import type { PackageJson } from 'type-fest';
 
-export function getPackageInfo(): PackageJson & { version: string; description: string } {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path.dirname(__filename);
+export function getPackageInfo(): { version: string; description: string } {
+  const possiblePaths = [
+    path.resolve(__dirname, '../../package.json'),
+    path.resolve(__dirname, '../package.json'),
+    path.resolve(process.cwd(), 'package.json'),
+  ];
 
-  const packageJsonPath = path.join(__dirname, '..', 'package.json');
+  for (const packageJsonPath of possiblePaths) {
+    try {
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = fs.readJSONSync(packageJsonPath) as PackageJson;
 
-  return fs.readJSONSync(packageJsonPath);
+        if (packageJson.name === 'git-intent') {
+          return {
+            version: packageJson.version || '0.0.0',
+            description: packageJson.description || 'Git Intent CLI',
+          };
+        }
+      }
+    } catch (error) {}
+  }
+
+  return {
+    version: '0.0.0',
+    description: 'Git Intent CLI',
+  };
 }

src/utils/get-package-info.ts

@@ -1,14 +1,54 @@
-import execa from 'execa';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'fs-extra';
 import { simpleGit } from 'simple-git';
 
+function execGit(args: string[], options: { input?: string; cwd?: string } = {}): string {
+  const { input, cwd } = options;
+
+  const result = spawnSync('git', args, {
+    input: input ? Buffer.from(input) : undefined,
+    cwd,
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  if (result.status !== 0) {
+    throw new Error(`Git command failed: git ${args.join(' ')}\n${result.stderr}`);
+  }
+
+  return result.stdout ? result.stdout.trim() : '';
+}
+
 export const createGit = (cwd?: string) => simpleGit(cwd);
 
-export async function checkIsRepo(cwd?: string): Promise<void> {
-  const git = createGit(cwd);
+export async function findGitRoot(startDir: string = process.cwd()): Promise<string> {
+  const dir = path.resolve(startDir);
+  const gitDir = path.join(dir, '.git');
+  if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {
+    return dir;
+  }
+
+  const parentDir = path.dirname(dir);
+  if (parentDir === dir) {
+    throw new Error('Not a git repository (or any of the parent directories)');
+  }
+
+  return findGitRoot(parentDir);
+}
+
+export async function checkIsRepo(cwd?: string): Promise<string> {
   try {
+    const git = createGit(cwd);
     await git.checkIsRepo();
+
+    return await findGitRoot(cwd);
   } catch {
-    throw new Error('Not a git repository');
+    try {
+      return await findGitRoot(cwd);
+    } catch (error) {
+      throw new Error('Not a git repository (or any of the parent directories)');
+    }
   }
 }
 
@@ -37,21 +77,40 @@ export async function getStatus(cwd?: string): Promise<string> {
 }
 
 export async function hashObject(content: string, cwd?: string): Promise<string> {
-  const { stdout } = await execa('git', ['hash-object', '-w', '--stdin'], { input: content, cwd });
-  return stdout.trim();
+  return execGit(['hash-object', '-w', '--stdin'], { input: content, cwd });
 }
 
 export async function createTree(treeContent: string, cwd?: string): Promise<string> {
-  const { stdout } = await execa('git', ['mktree'], { input: treeContent, cwd });
-  return stdout.trim();
+  if (!treeContent || treeContent.trim() === '') {
+    throw new Error('Invalid tree content: tree content cannot be empty');
+  }
+  return execGit(['mktree'], { input: treeContent, cwd });
 }
 
 export async function createCommitTree(treeHash: string, message: string, cwd?: string): Promise<string> {
-  const { stdout } = await execa('git', ['commit-tree', treeHash, '-m', message], { cwd });
-  return stdout.trim();
+  if (!treeHash || treeHash.trim() === '') {
+    throw new Error('Invalid tree hash: tree hash cannot be empty');
+  }
+
+  try {
+    const result = execGit(['commit-tree', treeHash, '-m', message], { cwd });
+
+    if (!result || result.trim() === '') {
+      throw new Error(`Failed to create commit tree from hash: ${treeHash}`);
+    }
+
+    return result;
+  } catch (error) {
+    console.error('Error creating commit tree:', error);
+    throw error;
+  }
 }
 
 export async function updateRef(refName: string, commitHash: string, cwd?: string): Promise<void> {
+  if (!commitHash || commitHash.trim() === '') {
+    throw new Error(`Invalid commit hash: commit hash cannot be empty for ref ${refName}`);
+  }
+
   const git = createGit(cwd);
   await git.raw(['update-ref', refName, commitHash]);
 }

src/utils/git.ts

@@ -162,6 +162,7 @@ export class GitIntentionalCommitStorage {
     await checkIsRepo(root);
 
     const refExists = await checkRefExists(`${this.REFS_PREFIX}/commits`, root);
+
     if (!refExists) {
       const initialData = this.getInitialData();
       const content = JSON.stringify(initialData, null, 2);
@@ -171,6 +172,10 @@ export class GitIntentionalCommitStorage {
       const treeHash = await createTree(treeContent, root);
       const commitHash = await createCommitTree(treeHash, 'Initialize intent commits', root);
 
+      if (!commitHash || commitHash.trim() === '') {
+        throw new Error('Failed to create commit: commit hash is empty');
+      }
+
       await updateRef(`${this.REFS_PREFIX}/commits`, commitHash, root);
     }
   }

src/utils/storage.ts

@@ -2,5 +2,5 @@ import { defineConfig } from 'tsup';
 
 export default defineConfig({
   entry: ['src/index.ts'],
-  format: ['esm'],
+  format: ['esm', 'cjs'],
 });