@misaelabanto/commita 0.1.2

package/src/git/git.service.ts

@@ -0,0 +1,147 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import simpleGit, { type SimpleGit } from 'simple-git';
+
+export interface FileChange {
+  path: string;
+  status: string;
+}
+
+export class GitService {
+  private git: SimpleGit;
+  private rootDir: string;
+
+  constructor(workingDir?: string) {
+    this.rootDir = workingDir || process.cwd();
+    this.git = simpleGit(this.rootDir);
+  }
+
+  getRootDir(): string {
+    return this.rootDir;
+  }
+
+  async init(): Promise<void> {
+    try {
+      const root = await this.git.revparse(['--show-toplevel']);
+      this.rootDir = root.trim();
+      this.git = simpleGit(this.rootDir);
+    } catch (error) {
+      // Fallback to cwd if not a git repo (will likely fail later but handles init)
+    }
+  }
+
+  async getStagedChanges(): Promise<FileChange[]> {
+    const status = await this.git.status();
+    return status.staged.map(path => ({
+      path,
+      status: 'staged',
+    }));
+  }
+
+  async getUnstagedChanges(): Promise<FileChange[]> {
+    const status = await this.git.status();
+    const modified = status.modified.map(path => ({ path, status: 'modified' }));
+    const notAdded = status.not_added.map(path => ({ path, status: 'new' }));
+    const deleted = status.deleted.map(path => ({ path, status: 'deleted' }));
+
+    return [...modified, ...notAdded, ...deleted];
+  }
+
+  async getAllChanges(): Promise<FileChange[]> {
+    const staged = await this.getStagedChanges();
+    const unstaged = await this.getUnstagedChanges();
+    return [...staged, ...unstaged];
+  }
+
+  async getDiff(files: string[], staged: boolean = false): Promise<string> {
+    if (files.length === 0) {
+      return '';
+    }
+
+    try {
+      const status = await this.git.status();
+      const newFiles = status.not_added;
+      const diffs: string[] = [];
+
+      for (const file of files) {
+        if (newFiles.includes(file) && !staged) {
+          const newFileDiff = await this.getNewFileDiff(file);
+          if (newFileDiff) {
+            diffs.push(newFileDiff);
+          }
+        } else {
+          const diffArgs = staged ? ['--cached', '--', file] : ['--', file];
+          const diff = await this.git.diff(diffArgs);
+          if (diff) {
+            diffs.push(diff);
+          }
+        }
+      }
+
+      return diffs.join('\n');
+    } catch (error) {
+      console.error('Error getting diff:', error);
+      return '';
+    }
+  }
+
+  private async getNewFileDiff(filePath: string): Promise<string> {
+    try {
+      const fullPath = join(this.rootDir, filePath);
+      if (!existsSync(fullPath)) {
+        return '';
+      }
+
+      const content = await readFile(fullPath, 'utf-8');
+      const lines = content.split('\n');
+
+      const diffHeader = `diff --git a/${filePath} b/${filePath}
+new file mode 100644
+index 0000000..0000000
+--- /dev/null
++++ b/${filePath}
+`;
+
+      const diffLines = lines.map(line => `+${line}`).join('\n');
+      return diffHeader + diffLines;
+    } catch (error) {
+      console.error(`Error reading new file ${filePath}:`, error);
+      return '';
+    }
+  }
+
+  async stageFiles(files: string[]): Promise<void> {
+    if (files.length === 0) return;
+    await this.git.add(files);
+  }
+
+  async unstageFiles(files: string[]): Promise<void> {
+    if (files.length === 0) return;
+    await this.git.reset(['HEAD', '--', ...files]);
+  }
+
+  async commit(message: string): Promise<void> {
+    await this.git.commit(message);
+  }
+
+  async getCurrentBranch(): Promise<string> {
+    const status = await this.git.status();
+    return status.current || 'main';
+  }
+
+  async push(): Promise<void> {
+    const branch = await this.getCurrentBranch();
+    await this.git.push('origin', branch);
+  }
+
+  async hasRemote(): Promise<boolean> {
+    try {
+      const remotes = await this.git.getRemotes();
+      return remotes.length > 0;
+    } catch {
+      return false;
+    }
+  }
+}
+

package/src/git/project-detector.ts

@@ -0,0 +1,89 @@
+import { readdirSync, statSync } from 'fs';
+import { join, relative } from 'path';
+
+export interface ProjectBoundary {
+  path: string;
+  manifestFile: string;
+}
+
+const MANIFEST_FILES = [
+  'package.json',
+  'Cargo.toml',
+  'go.mod',
+  'pyproject.toml',
+  'pom.xml',
+  'build.gradle',
+  'composer.json',
+  'pubspec.yaml',
+  'mix.exs',
+  'deno.json',
+];
+
+const SKIP_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'target',
+  'vendor',
+  '__pycache__',
+  '.venv',
+  '.next',
+  '.nuxt',
+  '.turbo',
+  '.cache',
+  'coverage',
+  'out',
+]);
+
+const MAX_DEPTH = 4;
+
+export class ProjectDetector {
+  static detect(rootDir: string): ProjectBoundary[] {
+    const boundaries: ProjectBoundary[] = [];
+    this.scan(rootDir, rootDir, 0, boundaries);
+    return boundaries;
+  }
+
+  private static scan(
+    dir: string,
+    rootDir: string,
+    depth: number,
+    boundaries: ProjectBoundary[],
+  ): void {
+    if (depth > MAX_DEPTH) return;
+
+    let entries: string[];
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+
+    const isRoot = dir === rootDir;
+
+    if (!isRoot) {
+      const manifest = entries.find(e => MANIFEST_FILES.includes(e));
+      if (manifest) {
+        boundaries.push({
+          path: relative(rootDir, dir),
+          manifestFile: manifest,
+        });
+        return; // Stop recursing into this project's internals
+      }
+    }
+
+    for (const entry of entries) {
+      if (SKIP_DIRS.has(entry) || entry.startsWith('.')) continue;
+
+      const fullPath = join(dir, entry);
+      try {
+        if (statSync(fullPath).isDirectory()) {
+          this.scan(fullPath, rootDir, depth + 1, boundaries);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+}

package/src/utils/pattern-matcher.ts

@@ -0,0 +1,39 @@
+import { minimatch } from 'minimatch';
+
+export class PatternMatcher {
+  private patterns: string[];
+
+  constructor(patterns: string[]) {
+    this.patterns = patterns;
+  }
+
+  shouldIgnore(filePath: string): boolean {
+    if (this.patterns.length === 0) {
+      return false;
+    }
+
+    return this.patterns.some(pattern =>
+      minimatch(filePath, pattern, { dot: true })
+    );
+  }
+
+  filterFiles<T extends { path: string }>(files: T[]): T[] {
+    if (this.patterns.length === 0) {
+      return files;
+    }
+
+    return files.filter(file => !this.shouldIgnore(file.path));
+  }
+
+  static parsePatterns(patternsString: string): string[] {
+    if (!patternsString || patternsString.trim() === '') {
+      return [];
+    }
+
+    return patternsString
+      .split(',')
+      .map(p => p.trim())
+      .filter(p => p.length > 0);
+  }
+}
+

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}