sncommit 1.0.0

package/src/index.tsx

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+import "./suppress-warnings";
+
+import { Command } from "commander";
+import { render } from "ink";
+import { App as BetterCommitApp } from "./components/App";
+import { ConfigApp } from "./components/ConfigApp";
+
+// Handle raw mode errors gracefully
+const handleRawModeError = (error: Error, fallbackMessage: string) => {
+  if (error.message.includes("Raw mode is not supported")) {
+    console.log(fallbackMessage);
+    process.exit(0);
+  }
+  throw error;
+};
+
+const program = new Command();
+
+program
+  .name("better-commit")
+  .description("AI-powered git commit message generator with beautiful TUI")
+  .version("1.0.0");
+
+// Add options
+program.option("-a, --all", "stage all files before committing");
+
+// Subcommand for config
+program
+  .command("config")
+  .description("Configure better-commit settings")
+  .action(async () => {
+    // Check TTY support first before doing anything
+    if (!process.stdin.isTTY) {
+      console.log("Configuration interface not supported in this terminal.");
+      console.log("Please try running in a compatible terminal like:");
+      console.log("- Windows Terminal");
+      console.log("- PowerShell with proper TTY support");
+      console.log("- Git Bash");
+      console.log("- WSL terminal");
+      process.exit(0);
+      return;
+    }
+
+    try {
+      let exitMessage = "";
+      const { waitUntilExit } = render(
+        <ConfigApp
+          onExit={(message) => {
+            if (message) exitMessage = message;
+          }}
+        />,
+        {
+          stdout: process.stdout,
+          stdin: process.stdin,
+          patchConsole: true,
+          exitOnCtrlC: false,
+        },
+      );
+      await waitUntilExit();
+      if (exitMessage) console.log(exitMessage);
+      process.exit(0);
+    } catch (error) {
+      handleRawModeError(
+        error as Error,
+        "Configuration interface not supported in this terminal.",
+      );
+    }
+  });
+
+// Default action - commit
+program.action(async () => {
+  const options = program.opts();
+
+  // Check TTY support first before doing any git operations
+  if (!process.stdin.isTTY) {
+    console.log("Interactive interface not supported in this terminal.");
+    console.log("Please try running in a compatible terminal like:");
+    console.log("- Windows Terminal");
+    console.log("- PowerShell with proper TTY support");
+    console.log("- Git Bash");
+    console.log("- WSL terminal");
+    process.exit(0);
+    return;
+  }
+
+  try {
+    // Check git status first to provide fallback behavior
+    const gitService = await import("./services/git").then(
+      (m) => new m.GitService(),
+    );
+    const isGitRepo = await gitService.isGitRepository();
+    if (!isGitRepo) {
+      console.log(
+        "Error: Not a git repository. Please run this command from inside a git repository.",
+      );
+      process.exit(0);
+      return;
+    }
+
+    if (options.all) {
+      const hasUnstaged = await gitService.hasUnstagedChanges();
+      if (hasUnstaged) {
+        await gitService.stageAll();
+      }
+    }
+
+    const hasStaged = await gitService.hasStagedChanges();
+    if (!hasStaged) {
+      const hasUnstaged = await gitService.hasUnstagedChanges();
+      if (hasUnstaged) {
+        console.log(
+          'No staged files. Use "git add ." or run "better-commit -a" to stage all files.',
+        );
+      } else {
+        console.log("No changes to commit. Working tree is clean.");
+      }
+      process.exit(0);
+      return;
+    }
+
+    // Only try to render if we have staged files
+    let exitMessage = "";
+    const { waitUntilExit } = render(
+      <BetterCommitApp
+        addAll={options.all || false}
+        onExit={(message) => {
+          if (message) exitMessage = message;
+        }}
+      />,
+      {
+        stdout: process.stdout,
+        stdin: process.stdin,
+        patchConsole: true,
+        exitOnCtrlC: false,
+      },
+    );
+    await waitUntilExit();
+    if (exitMessage) console.log(exitMessage);
+    process.exit(0);
+  } catch (error) {
+    handleRawModeError(
+      error as Error,
+      "Interactive interface not supported in this terminal. Please try running in a compatible terminal.",
+    );
+  }
+});
+
+program.parse();

package/src/services/git.ts

@@ -0,0 +1,128 @@
+import simpleGit, { SimpleGit } from "simple-git";
+import { GitFile, GitCommit } from "../types";
+
+export class GitService {
+  private git: SimpleGit;
+
+  constructor() {
+    this.git = simpleGit();
+  }
+
+  async isGitRepository(): Promise<boolean> {
+    try {
+      return await this.git.checkIsRepo();
+    } catch {
+      return false;
+    }
+  }
+
+  async getStagedFiles(): Promise<GitFile[]> {
+    try {
+      const status = await this.git.status();
+      const stagedFiles: GitFile[] = [];
+
+      // Add staged files
+      status.staged.forEach((file) => {
+        stagedFiles.push({
+          path: file,
+          status: "staged",
+          isStaged: true,
+        });
+      });
+
+      return stagedFiles;
+    } catch (error) {
+      throw new Error(`Failed to get staged files: ${error}`);
+    }
+  }
+
+  async getRecentCommits(limit: number = 50): Promise<GitCommit[]> {
+    try {
+      const log = await this.git.log({ maxCount: limit });
+
+      return log.all.map((commit) => ({
+        hash: commit.hash,
+        message: commit.message,
+        author: commit.author_name,
+        date: commit.date,
+      }));
+    } catch {
+      // Silently handle git history errors - don't show them to user
+      // This is common in new repositories with no commits
+      return [];
+    }
+  }
+
+  async commit(message: string): Promise<void> {
+    try {
+      await this.git.commit(message);
+    } catch (error) {
+      throw new Error(`Failed to commit: ${error}`);
+    }
+  }
+
+  async getDiff(): Promise<string> {
+    try {
+      const diff = await this.git.diff(["--cached"]);
+      return diff;
+    } catch {
+      // Silently fail - don't interfere with TUI
+      return "";
+    }
+  }
+
+  async getDiffStats(): Promise<{
+    added: number;
+    deleted: number;
+    modified: number;
+    renamed: number;
+    files: string[];
+  }> {
+    try {
+      const status = await this.git.status();
+      const diffStats = await this.git.diffSummary(["--cached"]);
+
+      return {
+        added: diffStats.insertions,
+        deleted: diffStats.deletions,
+        modified: status.modified.length,
+        renamed: status.renamed.length,
+        files: status.staged,
+      };
+    } catch {
+      // Silently fail - don't interfere with TUI
+      return { added: 0, deleted: 0, modified: 0, renamed: 0, files: [] };
+    }
+  }
+
+  async hasStagedChanges(): Promise<boolean> {
+    try {
+      const status = await this.git.status();
+      return status.staged.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  async stageAll(): Promise<void> {
+    try {
+      await this.git.add(".");
+    } catch {
+      throw new Error(`Failed to stage all files`);
+    }
+  }
+
+  async hasUnstagedChanges(): Promise<boolean> {
+    try {
+      const status = await this.git.status();
+      return (
+        status.not_added.length > 0 ||
+        status.modified.length > 0 ||
+        status.created.length > 0 ||
+        status.deleted.length > 0
+      );
+    } catch {
+      return false;
+    }
+  }
+}

package/src/services/groq.ts

@@ -0,0 +1,360 @@
+import Groq from "groq-sdk";
+import { CommitSuggestion, GitFile, GitCommit, Config } from "../types";
+
+export class GroqService {
+  private client: Groq;
+  private config: Config;
+
+  constructor(apiKey: string, config: Config) {
+    this.client = new Groq({ apiKey });
+    this.config = config;
+  }
+
+  async generateCommitSuggestions(
+    stagedFiles: GitFile[],
+    diff: string,
+    recentCommits: GitCommit[] = [],
+    _diffStats?: {
+      added: number;
+      deleted: number;
+      modified: number;
+      renamed: number;
+      files: string[];
+    },
+  ): Promise<CommitSuggestion[]> {
+    const prompt = this.buildPrompt(stagedFiles, diff, recentCommits);
+
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "llama-3.1-8b-instant",
+        messages: [
+          {
+            role: "system",
+            content:
+              "You are an expert at writing clear, concise, and meaningful git commit messages.\n" +
+              "Generate commit messages that follow best practices and are helpful for future developers.\n" +
+              "IMPORTANT: Output your response in strict JSON format with the following schema:\n" +
+              '{\n  "suggestions": [\n    {\n      "message": "commit message here",\n      "type": "feat/fix/etc",\n      "description": "brief explanation"\n    }\n  ]\n}',
+          },
+          {
+            role: "user",
+            content: prompt,
+          },
+        ],
+        // response_format: { type: "json_object" }, // Not all models support this, so we rely on system prompt + parsing
+        max_tokens: 2048, // Increased for reasoning models
+        temperature: 0.7,
+      });
+
+      const content = response.choices[0]?.message?.content;
+
+      if (!content) {
+        throw new Error("No response from Groq API");
+      }
+
+      return this.parseSuggestions(content);
+    } catch (e) {
+      console.error("Error generating suggestions:", e);
+      // Fallback to mock suggestions when API fails (silently handle)
+      const fallbackSuggestions = this.getFallbackSuggestions(stagedFiles);
+      return fallbackSuggestions.map((s) => ({ ...s, isFallback: true }));
+    }
+  }
+
+  async generateCommitSuggestionsFromCustomInput(
+    stagedFiles: GitFile[],
+    diff: string,
+    userInput: string,
+    recentCommits: GitCommit[] = [],
+    diffStats?: {
+      added: number;
+      deleted: number;
+      modified: number;
+      renamed: number;
+      files: string[];
+    },
+  ): Promise<CommitSuggestion[]> {
+    const prompt = this.buildPromptFromCustomInput(
+      stagedFiles,
+      diff,
+      userInput,
+      recentCommits,
+      diffStats,
+    );
+
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "llama-3.1-8b-instant",
+        messages: [
+          {
+            role: "system",
+            content:
+              "You are an expert at writing clear, concise, and meaningful git commit messages.\n" +
+              "Generate commit messages that follow best practices and are helpful for future developers.\n" +
+              "IMPORTANT: Output your response in strict JSON format with the following schema:\n" +
+              '{\n  "suggestions": [\n    {\n      "message": "commit message here",\n      "type": "feat/fix/etc",\n      "description": "brief explanation"\n    }\n  ]\n}',
+          },
+          {
+            role: "user",
+            content: prompt,
+          },
+        ],
+        // response_format: { type: "json_object" },
+        max_tokens: 2048,
+        temperature: 0.7,
+      });
+
+      const content = response.choices[0]?.message?.content;
+      if (!content) {
+        throw new Error("No response from Groq API");
+      }
+
+      return this.parseSuggestions(content);
+    } catch (e) {
+      console.error("Error generating suggestions:", e);
+      // Fallback to mock suggestions when API fails (silently handle)
+      const fallbackSuggestions = this.getFallbackSuggestions(stagedFiles);
+      return fallbackSuggestions.map((s) => ({ ...s, isFallback: true }));
+    }
+  }
+
+  private buildPromptFromCustomInput(
+    stagedFiles: GitFile[],
+    diff: string,
+    userInput: string,
+    recentCommits: GitCommit[],
+    diffStats?: {
+      added: number;
+      deleted: number;
+      modified: number;
+      renamed: number;
+      files: string[];
+    },
+  ): string {
+    const filesText = stagedFiles.map((f) => `- ${f.path}`).join("\n");
+    const recentCommitsText = recentCommits
+      .slice(0, 5)
+      .map((c) => `- ${c.message}`)
+      .join("\n");
+
+    let styleInstruction = "";
+    switch (this.config.commitStyle) {
+      case "conventional":
+        styleInstruction =
+          "Use conventional commit format (feat:, fix:, docs:, etc.)";
+        break;
+      case "simple":
+        styleInstruction = "Keep messages simple and concise";
+        break;
+      case "detailed":
+        styleInstruction = "Include detailed descriptions of changes";
+        break;
+    }
+
+    const customPrompt = this.config.customPrompt
+      ? `\nAdditional instructions: ${this.config.customPrompt}`
+      : "";
+
+    const statsText = diffStats
+      ? `
+Change statistics:
+- ${diffStats.added} lines added
+- ${diffStats.deleted} lines deleted
+- ${diffStats.modified} files modified
+- ${diffStats.renamed} files renamed
+- ${diffStats.files.length} total files changed`
+      : "";
+
+    return `The user wants commit messages based on their description: "${userInput}"
+
+Analyze the following git changes and generate 4 different commit message suggestions that match the user's intent.
+
+IMPORTANT: Carefully analyze the git diff below to understand WHAT changes were actually made:
+- Look for added/removed/modified lines (lines starting with +, -, or @@)
+- Identify if files were added, deleted, or modified
+- Understand the nature of the changes (new features, bug fixes, refactoring, etc.)
+- Match the user's description: "${userInput}"
+
+Files staged for commit:
+${filesText}${statsText}
+
+${diff
+        ? `Complete git diff (analyze this carefully to understand the actual changes):\n${diff.slice(
+          0,
+          2000,
+        )}\n${diff.length > 2000 ? "...(truncated)" : ""}`
+        : "No diff available"
+      }
+
+${recentCommitsText
+        ? `Recent commit history for reference:\n${recentCommitsText}`
+        : ""
+      }
+
+Requirements:
+- Generate exactly 4 different commit messages
+- Each message should be 50-72 characters
+- ${styleInstruction}
+- Make them specific to the actual changes shown AND match the user's intent: "${userInput}"
+- Focus on what changed, not how it changed
+${customPrompt}
+
+Output ONLY valid JSON.`;
+  }
+
+  private getFallbackSuggestions(stagedFiles: GitFile[]): CommitSuggestion[] {
+    const fileNames =
+      stagedFiles.length > 0
+        ? stagedFiles
+          .map((f) => f.path)
+          .slice(0, 3)
+          .join(", ") + (stagedFiles.length > 3 ? "..." : "")
+        : "files";
+
+    const suggestions = [
+      {
+        message: `feat: add ${fileNames}`,
+        type: "feat",
+        description: `feat: add ${fileNames}`,
+      },
+      {
+        message: `fix: update ${fileNames}`,
+        type: "fix",
+        description: `fix: update ${fileNames}`,
+      },
+      {
+        message: `refactor: improve ${fileNames}`,
+        type: "refactor",
+        description: `refactor: improve ${fileNames}`,
+      },
+      {
+        message: `docs: update ${fileNames}`,
+        type: "docs",
+        description: `docs: update ${fileNames}`,
+      },
+    ];
+
+    return suggestions;
+  }
+
+  private buildPrompt(
+    stagedFiles: GitFile[],
+    diff: string,
+    recentCommits: GitCommit[],
+    diffStats?: {
+      added: number;
+      deleted: number;
+      modified: number;
+      renamed: number;
+      files: string[];
+    },
+  ): string {
+    const filesText = stagedFiles.map((f) => `- ${f.path}`).join("\n");
+    const recentCommitsText = recentCommits
+      .slice(0, 5)
+      .map((c) => `- ${c.message}`)
+      .join("\n");
+
+    let styleInstruction = "";
+    switch (this.config.commitStyle) {
+      case "conventional":
+        styleInstruction =
+          "Use conventional commit format (feat:, fix:, docs:, etc.)";
+        break;
+      case "simple":
+        styleInstruction = "Keep messages simple and concise";
+        break;
+      case "detailed":
+        styleInstruction = "Include detailed descriptions of changes";
+        break;
+    }
+
+    const customPrompt = this.config.customPrompt
+      ? `\nAdditional instructions: ${this.config.customPrompt}`
+      : "";
+
+    const statsText = diffStats
+      ? `
+Change statistics:
+- ${diffStats.added} lines added
+- ${diffStats.deleted} lines deleted
+- ${diffStats.modified} files modified
+- ${diffStats.renamed} files renamed
+- ${diffStats.files.length} total files changed`
+      : "";
+
+    return `Analyze the following git changes and generate 4 different commit message suggestions.
+
+IMPORTANT: Carefully analyze the git diff below to understand WHAT changes were actually made:
+- Look for added/removed/modified lines (lines starting with +, -, or @@)
+- Identify if files were added, deleted, or modified
+- Understand the nature of the changes (new features, bug fixes, refactoring, etc.)
+- DO NOT assume all changes are "add" operations - check the diff carefully
+
+Files staged for commit:
+${filesText}${statsText}
+
+${diff
+        ? `Complete git diff (analyze this carefully to understand the actual changes):\n${diff.slice(
+          0,
+          2000,
+        )}\n${diff.length > 2000 ? "...(truncated)" : ""}`
+        : "No diff available"
+      }
+
+${recentCommitsText
+        ? `Recent commit history for reference:\n${recentCommitsText}`
+        : ""
+      }
+
+Requirements:
+- Generate exactly 4 different commit messages
+- Each message should be 50-72 characters
+- ${styleInstruction}
+- Make them specific to the actual changes shown
+- Focus on what changed, not how it changed
+${customPrompt}
+
+Output ONLY valid JSON.`;
+  }
+
+  private parseSuggestions(content: string): CommitSuggestion[] {
+    try {
+      // Find the JSON object in the content (it might be wrapped in markdown or have extra text)
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (parsed.suggestions && Array.isArray(parsed.suggestions)) {
+          return parsed.suggestions.map((s: any) => ({
+            message: s.message || "",
+            type: s.type || this.extractType(s.message || ""),
+            description: s.description || s.message || "",
+          })).slice(0, 4);
+        }
+      }
+      throw new Error("Invalid JSON structure");
+    } catch (e) {
+      console.warn("Failed to parse JSON suggestions, falling back to basic parsing:", e);
+      // Fallback to basic line parsing if JSON fails
+      const lines = content.split("\n").filter((line) => line.trim());
+      const suggestions: CommitSuggestion[] = [];
+
+      for (const line of lines) {
+        const match = line.match(/^\d+\.\s*(.+)$/);
+        if (match && suggestions.length < 4) {
+          suggestions.push({
+            message: match[1].trim(),
+            type: this.extractType(match[1]),
+            description: match[1].trim(),
+          });
+        }
+      }
+      return suggestions;
+    }
+  }
+
+  private extractType(message: string): string {
+    const match = message.match(/^(\w+):/);
+    return match ? match[1] : "feat";
+  }
+}

package/src/suppress-warnings.ts

@@ -0,0 +1,18 @@
+// Suppress punycode and url.parse deprecation warnings
+const originalEmit = process.emit;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+process.emit = function (name: any, data: any, ...args: any[]): boolean {
+  if (
+    name === "warning" &&
+    typeof data === "object" &&
+    data &&
+    data.name === "DeprecationWarning" &&
+    data.message &&
+    (data.message.includes("punycode") || data.message.includes("url.parse"))
+  ) {
+    return false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  return (originalEmit as Function).apply(process, [name, data, ...args]);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+} as any;

package/src/types/index.ts

@@ -0,0 +1,36 @@
+export interface Config {
+  groqApiKey?: string;
+  model?: string;
+  maxHistoryCommits?: number;
+  commitStyle?: "conventional" | "simple" | "detailed";
+  language?: string;
+  customPrompt?: string;
+}
+
+export interface GitFile {
+  path: string;
+  status: string;
+  isStaged: boolean;
+}
+
+export interface CommitSuggestion {
+  message: string;
+  type?: string;
+  description?: string;
+  isFallback?: boolean;
+}
+
+export interface GitCommit {
+  hash: string;
+  message: string;
+  author: string;
+  date: string;
+}
+
+export interface AppState {
+  stagedFiles: GitFile[];
+  suggestions: CommitSuggestion[];
+  selectedIndex: number;
+  isLoading: boolean;
+  error?: string;
+}