feat: add error and event modules (#22)

* feat: add error and event modules

* chore: add changeset

* fix: delete unused import

* chore: reorder labeler patterns to attempt .changeset exclusion

* refactor

Author: kangju2000

.changeset/modern-schools-shout.md

@@ -0,0 +1,7 @@
+---
+"@offlegacy/git-intent-core": patch
+"git-intent": patch
+---
+
+feat: add error and event modules
+  

.github/labeler.yml

@@ -8,7 +8,7 @@ core:
 
 documentation:
 - changed-files:
-  - any-glob-to-any-file: ['**/*.md', '**/*.mdx', '!.changeset/**/*.md']
+  - any-glob-to-any-file: ['!changeset/**/*.md', '**/*.md', '**/*.mdx']
 
 github-actions:
 - changed-files:

packages/core/src/errors/index.ts

@@ -0,0 +1,19 @@
+export class GitIntentError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string
+  ) {
+    super(message);
+    this.name = 'GitIntentError';
+  }
+}
+
+export class GitError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string
+  ) {
+    super(message);
+    this.name = 'GitError';
+  }
+}

packages/core/src/events/index.ts

@@ -0,0 +1,48 @@
+export type EventMap = Record<string, unknown>;
+export type EventHandler<T = unknown> = (data: T) => void;
+
+export class TypedEventEmitter<T extends EventMap> {
+  private listeners: Partial<Record<keyof T, EventHandler[]>> = {};
+
+  on<K extends keyof T>(event: K, handler: EventHandler<T[K]>): void {
+    if (!this.listeners[event]) {
+      this.listeners[event] = [];
+    }
+
+    this.listeners[event].push(handler as EventHandler);
+  }
+
+  off<K extends keyof T>(event: K, handler?: EventHandler<T[K]>): void {
+    if (!handler) {
+      delete this.listeners[event];
+      return;
+    }
+
+    const handlers = this.listeners[event];
+    if (handlers) {
+      this.listeners[event] = handlers.filter((h) => h !== handler) as EventHandler[];
+    }
+  }
+
+  emit<K extends keyof T>(event: K, data: T[K]): void {
+    const handlers = this.listeners[event];
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(data);
+      }
+    }
+  }
+
+  once<K extends keyof T>(event: K, handler: EventHandler<T[K]>): void {
+    const onceHandler: EventHandler = (data: unknown) => {
+      this.off(event, onceHandler as EventHandler<T[K]>);
+      handler(data as T[K]);
+    };
+
+    this.on(event, onceHandler as EventHandler<T[K]>);
+  }
+}
+
+export function createEmitter<T extends EventMap>(): TypedEventEmitter<T> {
+  return new TypedEventEmitter<T>();
+}

packages/core/src/git/index.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './service.js';
+export * from './refs.js';
+
+import { gitService } from './service.js';
+export default gitService;

packages/core/src/utils/git-refs.ts renamed to packages/core/src/git/refs.ts

@@ -1,4 +1,4 @@
-import { git } from './git.js';
+import { gitService } from './service.js';
 
 class GitRefsService {
   private static instance: GitRefsService;
@@ -16,7 +16,7 @@ class GitRefsService {
     if (!treeContent || treeContent.trim() === '') {
       throw new Error('Invalid tree content: tree content cannot be empty');
     }
-    return git.execGit(['mktree'], { input: treeContent, cwd });
+    return gitService.execGit(['mktree'], { input: treeContent, cwd });
   }
 
   async createCommitTree(treeHash: string, message: string, cwd?: string): Promise<string> {
@@ -25,7 +25,7 @@ class GitRefsService {
     }
 
     try {
-      const result = git.execGit(['commit-tree', treeHash, '-m', message], { cwd });
+      const result = gitService.execGit(['commit-tree', treeHash, '-m', message], { cwd });
 
       if (!result || result.trim() === '') {
         throw new Error(`Failed to create commit tree from hash: ${treeHash}`);
@@ -43,16 +43,16 @@ class GitRefsService {
       throw new Error(`Invalid commit hash: commit hash cannot be empty for ref ${refName}`);
     }
 
-    await git.raw(['update-ref', refName, commitHash], cwd);
+    await gitService.raw(['update-ref', refName, commitHash], cwd);
   }
 
   async deleteRef(refName: string, cwd?: string): Promise<void> {
-    await git.raw(['update-ref', '-d', refName], cwd);
+    await gitService.raw(['update-ref', '-d', refName], cwd);
   }
 
   async checkRefExists(refName: string, cwd?: string): Promise<boolean> {
     try {
-      await git.raw(['show-ref', '--verify', refName], cwd);
+      await gitService.raw(['show-ref', '--verify', refName], cwd);
       return true;
     } catch {
       return false;
@@ -61,7 +61,7 @@ class GitRefsService {
 
   async showRef(refPath: string, cwd?: string): Promise<string> {
     try {
-      return await git.raw(['show', refPath], cwd);
+      return await gitService.raw(['show', refPath], cwd);
     } catch (error) {
       throw new Error(`Failed to show ref: ${refPath}`);
     }

packages/core/src/git/service.ts

@@ -0,0 +1,143 @@
+import { spawnSync } from 'node:child_process';
+import { type SimpleGit, simpleGit } from 'simple-git';
+import { GitError } from '../errors/index.js';
+import type { GitServiceInterface } from './types.js';
+
+class GitService implements GitServiceInterface {
+  private static instance: GitService;
+  private gitInstances: Map<string, SimpleGit> = new Map();
+  private defaultGit: SimpleGit;
+
+  private constructor() {
+    this.defaultGit = simpleGit();
+    this.gitInstances.set('default', this.defaultGit);
+  }
+
+  static getInstance(): GitService {
+    if (!GitService.instance) {
+      GitService.instance = new GitService();
+    }
+    return GitService.instance;
+  }
+
+  getGit(cwd?: string): SimpleGit {
+    if (!cwd) {
+      return this.defaultGit;
+    }
+
+    const cacheKey = cwd;
+    if (!this.gitInstances.has(cacheKey)) {
+      this.gitInstances.set(cacheKey, simpleGit(cwd));
+    }
+
+    return this.gitInstances.get(cacheKey) as SimpleGit;
+  }
+
+  execGit(args: string[], options: { input?: string; cwd?: string } = {}): string {
+    const { input, cwd } = options;
+
+    try {
+      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 GitError(`Git command failed: git ${args.join(' ')}\n${result.stderr}`, 'GIT_COMMAND_FAILED');
+      }
+
+      return result.stdout ? result.stdout.trim() : '';
+    } catch (error) {
+      if (error instanceof GitError) {
+        throw error;
+      }
+      throw new GitError(`Git execution error: ${(error as Error).message}`, 'GIT_EXEC_ERROR');
+    }
+  }
+
+  async checkIsRepo(cwd?: string): Promise<boolean> {
+    try {
+      const git = this.getGit(cwd);
+      const isRepo = await git.checkIsRepo();
+      return isRepo;
+    } catch (error) {
+      throw new GitError(
+        `Failed to check if directory is a Git repository: ${(error as Error).message}`,
+        'CHECK_REPO_ERROR'
+      );
+    }
+  }
+
+  async getRepoRoot(cwd?: string): Promise<string> {
+    try {
+      const git = this.getGit(cwd);
+      const root = await git.revparse(['--show-toplevel']);
+      return root.trim();
+    } catch (error) {
+      throw new GitError(`Failed to get repository root: ${(error as Error).message}`, 'REPO_ROOT_ERROR');
+    }
+  }
+
+  async getCurrentBranch(cwd?: string): Promise<string> {
+    try {
+      const git = this.getGit(cwd);
+      const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+      return branch.trim();
+    } catch (error) {
+      throw new GitError(`Failed to get current branch: ${(error as Error).message}`, 'CURRENT_BRANCH_ERROR');
+    }
+  }
+
+  async getStatus(cwd?: string): Promise<any> {
+    try {
+      const git = this.getGit(cwd);
+      return await git.status();
+    } catch (error) {
+      throw new GitError(`Failed to get repository status: ${(error as Error).message}`, 'STATUS_ERROR');
+    }
+  }
+
+  async hasStagedFiles(cwd?: string): Promise<boolean> {
+    try {
+      const status = await this.getStatus(cwd);
+      return status.staged.length > 0;
+    } catch (error) {
+      throw new GitError(`Failed to check for staged files: ${(error as Error).message}`, 'STAGED_FILES_ERROR');
+    }
+  }
+
+  async createCommit(message: string, cwd?: string): Promise<string> {
+    try {
+      const git = this.getGit(cwd);
+      const result = await git.commit(message);
+      return result.commit;
+    } catch (error) {
+      throw new GitError(`Failed to create commit: ${(error as Error).message}`, 'CREATE_COMMIT_ERROR');
+    }
+  }
+
+  async hashObject(content: string, cwd?: string): Promise<string> {
+    try {
+      return this.execGit(['hash-object', '-w', '--stdin'], { input: content, cwd });
+    } catch (error) {
+      throw new GitError(`Failed to hash object: ${(error as Error).message}`, 'HASH_OBJECT_ERROR');
+    }
+  }
+
+  async raw(commands: string[], cwd?: string): Promise<string> {
+    try {
+      const git = this.getGit(cwd);
+      return await git.raw(commands);
+    } catch (error) {
+      throw new GitError(`Failed to execute raw git command: ${(error as Error).message}`, 'RAW_COMMAND_ERROR');
+    }
+  }
+}
+
+export function createGitService(): GitServiceInterface {
+  return GitService.getInstance();
+}
+
+export const gitService = GitService.getInstance();

packages/core/src/git/types.ts

@@ -0,0 +1,14 @@
+import type { SimpleGit } from 'simple-git';
+
+export interface GitServiceInterface {
+  getGit(cwd?: string): SimpleGit;
+  execGit(args: string[], options?: { input?: string; cwd?: string }): string;
+  checkIsRepo(cwd?: string): Promise<boolean>;
+  getRepoRoot(cwd?: string): Promise<string>;
+  getCurrentBranch(cwd?: string): Promise<string>;
+  getStatus(cwd?: string): Promise<any>;
+  hasStagedFiles(cwd?: string): Promise<boolean>;
+  createCommit(message: string, cwd?: string): Promise<string>;
+  hashObject(content: string, cwd?: string): Promise<string>;
+  raw(commands: string[], cwd?: string): Promise<string>;
+}

packages/core/src/index.ts

@@ -1,7 +1,8 @@
 export * from './types/intent.js';
+export * from './errors/index.js';
+export * from './events/index.js';
+export * from './git/index.js';
+export * from './storage/index.js';
 
 export { generateId } from './utils/generateId.js';
 export { getPackageInfo } from './utils/get-package-info.js';
-export { git } from './utils/git.js';
-export { gitRefs } from './utils/git-refs.js';
-export { storage } from './utils/storage.js';