gims 0.4.2 → 0.4.3

package/README.md

@@ -1,6 +1,4 @@
-Here’s a **complete usage guide** for `gims` (Git Made Simple) CLI tool:
 
----
 
 ## 🚀 Installation
 
@@ -139,12 +137,4 @@ g b 1 try-feature           # Branch out from earlier version
 * [`@google-ai/gemini`](https://www.npmjs.com/package/@google-ai/gemini) – Gemini SDK
 * [`commander`](https://www.npmjs.com/package/commander) – CLI argument parser
 
----
-
-Let me know if you’d like to:
-
-* Add auto-push branch creation
-* Show full diff preview
-* Add emojis, scopes, or conventional commits
-* Bundle this as a GUI as well!
 

package/bin/gims.js

@@ -2,34 +2,10 @@
 
 /*
   gims (Git Made Simple) CLI
-  Features:
-    - Initialize repository (init alias: i)
-    - Auto commit with AI-generated messages (Gemini or OpenAI)
-      Modes:
-        * local (alias: l)
-        * online (alias: o)
-    - Navigation:
-        * list (alias: ls): numbered git log --oneline
-        * largelist (alias: ll): full git log --no-pager
-        * branch <commit|#> [name] (alias: b)
-        * reset <commit|#> [--hard] (alias: r)
-        * revert <commit|#> (alias: rv)
-
-  Env vars:
-    - GEMINI_API_KEY: use Google Gemini API
-    - OPENAI_API_KEY: fallback to OpenAI if Gemini not set
-    - none: fallback to generic commit messages
-
-  Usage:
-    npm install -g gims
-    export GEMINI_API_KEY=...
-    export OPENAI_API_KEY=...
-    gims init   # or g i
-    gims local  # or g l
 */
-
 const { Command } = require('commander');
 const simpleGit = require('simple-git');
+const clipboard = require('clipboardy');
 const process = require('process');
 const { OpenAI } = require('openai');
 const { GoogleGenAI } = require('@google/genai');
@@ -37,131 +13,293 @@ const { GoogleGenAI } = require('@google/genai');
 const program = new Command();
 const git = simpleGit();
 
-// Setup AI clients
-const hasGemini = !!process.env.GEMINI_API_KEY;
-const hasOpenAI = !hasGemini && !!process.env.OPENAI_API_KEY;
-let genai, openai;
+// Safe log: returns { all: [] } on empty repo
+async function safeLog() {
+  try {
+    return await git.log();
+  } catch (e) {
+    if (/does not have any commits/.test(e.message)) return { all: [] };
+    throw e;
+  }
+}
 
-if (hasGemini) {
-  genai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
-} else if (hasOpenAI) {
-  openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+// Clean up AI-generated commit message
+function cleanCommitMessage(message) {
+  // Remove markdown code blocks and formatting
+  let cleaned = message
+    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+    .replace(/`([^`]+)`/g, '$1')    // Remove inline code formatting
+    .replace(/^\s*[-*+]\s*/gm, '')  // Remove bullet points
+    .replace(/^\s*\d+\.\s*/gm, '')  // Remove numbered lists
+    .replace(/^\s*#+\s*/gm, '')     // Remove headers
+    .replace(/\*\*(.*?)\*\*/g, '$1') // Remove bold formatting
+    .replace(/\*(.*?)\*/g, '$1')     // Remove italic formatting
+    .trim();
+  
+  // Take only the first line if multiple lines exist
+  const firstLine = cleaned.split('\n')[0].trim();
+  
+  // Ensure it's not too long
+  return firstLine.length > 72 ? firstLine.substring(0, 69) + '...' : firstLine;
 }
 
-async function generateCommitMessage(diff) {
-  if (hasGemini) {
-    const res = await genai.models.generateContent({
-      model: 'gemini-2.0-flash',
-      contents: `Write a concise git commit message for these changes:\n${diff}`,
-    });
-    return res.text.trim();
+// Estimate tokens (rough approximation: 1 token ≈ 4 characters)
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
+// Generate commit message with multiple fallback strategies
+async function generateCommitMessage(rawDiff) {
+  const MAX_TOKENS = 100000; // Conservative limit (well below 128k)
+  const MAX_CHARS = MAX_TOKENS * 4;
+  
+  let content = rawDiff;
+  let strategy = 'full';
+
+  // Strategy 1: Check if full diff is too large
+  if (estimateTokens(rawDiff) > MAX_TOKENS) {
+    strategy = 'summary';
+    try {
+      const summary = await git.diffSummary();
+      content = summary.files
+        .map(f => `${f.file}: +${f.insertions} -${f.deletions}`)
+        .join('\n');
+    } catch (e) {
+      strategy = 'fallback';
+      content = 'Large changes across multiple files';
+    }
   }
 
-  if (hasOpenAI) {
-    const res = await openai.chat.completions.create({
-      model: 'gpt-4o-mini',
-      messages: [{ role: 'user', content: `Write a concise git commit message for these changes:\n${diff}` }],
-      temperature: 0.5,
-    });
-    return res.choices[0].message.content.trim();
+  // Strategy 2: If summary is still too large, use status
+  if (strategy === 'summary' && estimateTokens(content) > MAX_TOKENS) {
+    strategy = 'status';
+    try {
+      const status = await git.status();
+      const modified = status.modified.slice(0, 10);
+      const created = status.created.slice(0, 10);
+      const deleted = status.deleted.slice(0, 10);
+      
+      content = [
+        modified.length > 0 ? `Modified: ${modified.join(', ')}` : '',
+        created.length > 0 ? `Added: ${created.join(', ')}` : '',
+        deleted.length > 0 ? `Deleted: ${deleted.join(', ')}` : ''
+      ].filter(Boolean).join('\n');
+      
+      if (status.files.length > 30) {
+        content += `\n... and ${status.files.length - 30} more files`;
+      }
+    } catch (e) {
+      strategy = 'fallback';
+      content = 'Large changes across multiple files';
+    }
+  }
+
+  // Strategy 3: If still too large, truncate
+  if (estimateTokens(content) > MAX_TOKENS) {
+    strategy = 'truncated';
+    content = content.substring(0, MAX_CHARS - 1000) + '\n... (truncated)';
+  }
+
+  const prompts = {
+    full: 'Write a concise git commit message for these changes:',
+    summary: 'Changes are large; using summary. Write a concise git commit message for these changes:',
+    status: 'Many files changed. Write a concise git commit message based on these file changes:',
+    truncated: 'Large diff truncated. Write a concise git commit message for these changes:',
+    fallback: 'Write a concise git commit message for:'
+  };
+
+  const prompt = `${prompts[strategy]}\n${content}`;
+
+  // Final safety check
+  if (estimateTokens(prompt) > MAX_TOKENS) {
+    console.warn('Changes too large for AI analysis, using default message');
+    return 'Update multiple files';
+  }
+
+  let message = 'Update project code'; // Default fallback
+
+  try {
+    if (process.env.GEMINI_API_KEY) {
+      const genai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
+      const res = await genai.models.generateContent({ 
+        model: 'gemini-2.0-flash', 
+        contents: prompt 
+      });
+      message = (await res.response.text()).trim();
+    } else if (process.env.OPENAI_API_KEY) {
+      const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+      const res = await openai.chat.completions.create({
+        model: 'gpt-4o-mini',
+        messages: [{ role: 'user', content: prompt }],
+        temperature: 0.5,
+        max_tokens: 100 // Limit response length
+      });
+      message = res.choices[0].message.content.trim();
+    }
+  } catch (error) {
+    if (error.code === 'context_length_exceeded') {
+      console.warn('Content still too large for AI, using default message');
+      return 'Update multiple files';
+    }
+    console.warn('AI generation failed:', error.message);
   }
 
-  // fallback generic
-  return 'Update project code';
+  return cleanCommitMessage(message);
 }
 
 async function resolveCommit(input) {
   if (/^\d+$/.test(input)) {
-    const { all } = await git.log();
-    const idx = parseInt(input, 10) - 1;
+    const { all } = await safeLog();
+    const idx = Number(input) - 1;
     if (idx < 0 || idx >= all.length) throw new Error('Index out of range');
     return all[idx].hash;
   }
   return input;
 }
 
-program.name('gims').alias('g').version('0.4.2');
+async function hasChanges() {
+  const status = await git.status();
+  return status.files.length > 0;
+}
+
+program.name('gims').alias('g').version('0.4.3');
 
 program.command('init').alias('i')
   .description('Initialize a new Git repository')
+  .action(async () => { await git.init(); console.log('Initialized repo.'); });
+
+program.command('clone <repo>').alias('c')
+  .description('Clone a Git repository')
+  .action(async (repo) => {
+    try { await git.clone(repo); console.log(`Cloned ${repo}`); }
+    catch (e) { console.error('Clone error:', e.message); }
+  });
+
+program.command('suggest').alias('s')
+  .description('Suggest commit message and copy to clipboard')
   .action(async () => {
-    await git.init();
-    console.log('Initialized repo.');
+    if (!(await hasChanges())) {
+      return console.log('No changes to suggest.');
+    }
+
+    const { all } = await safeLog();
+    const isFirst = all.length === 0;
+    
+    // Always add changes first
+    await git.add('.');
+    
+    // Get the appropriate diff
+    const rawDiff = await git.diff(['--cached']);
+    
+    if (!rawDiff.trim()) {
+      return console.log('No changes to suggest.');
+    }
+    
+    const msg = await generateCommitMessage(rawDiff);
+    
+    try {
+      clipboard.writeSync(msg);
+      console.log(`Suggested: "${msg}" (copied to clipboard)`);
+    } catch (error) {
+      console.log(`Suggested: "${msg}" (clipboard copy failed)`);
+    }
   });
 
-// Local commit: stage all, get staged diff, AI message, commit
 program.command('local').alias('l')
   .description('AI-powered local commit')
   .action(async () => {
-    // stage all changes first
+    if (!(await hasChanges())) {
+      return console.log('No changes to commit.');
+    }
+
+    const { all } = await safeLog();
+    const isFirst = all.length === 0;
+    
+    // Always add changes first
     await git.add('.');
-    // get diff of staged changes
-    const diff = await git.diff(['--cached']);
-    if (!diff) return console.log('No changes to commit.');
-    console.log('Generating commit message...');
-    const msg = await generateCommitMessage(diff);
+    
+    // Get the appropriate diff
+    const rawDiff = await git.diff(['--cached']);
+    
+    if (!rawDiff.trim()) {
+      return console.log('No changes to commit.');
+    }
+    
+    const msg = await generateCommitMessage(rawDiff);
     await git.commit(msg);
     console.log(`Committed locally: "${msg}"`);
   });
 
-// Online commit: stage, diff, message, commit, push
 program.command('online').alias('o')
   .description('AI commit + push')
   .action(async () => {
+    if (!(await hasChanges())) {
+      return console.log('No changes to commit.');
+    }
+
+    const { all } = await safeLog();
+    const isFirst = all.length === 0;
+    
+    // Always add changes first
     await git.add('.');
-    const diff = await git.diff(['--cached']);
-    if (!diff) return console.log('No changes to commit.');
-    console.log('Generating commit message...');
-    const msg = await generateCommitMessage(diff);
+    
+    // Get the appropriate diff
+    const rawDiff = await git.diff(['--cached']);
+    
+    if (!rawDiff.trim()) {
+      return console.log('No changes to commit.');
+    }
+    
+    const msg = await generateCommitMessage(rawDiff);
     await git.commit(msg);
     await git.push();
     console.log(`Committed & pushed: "${msg}"`);
   });
 
+program.command('pull').alias('p')
+  .description('Pull latest changes')
+  .action(async () => {
+    try { await git.pull(); console.log('Pulled latest.'); }
+    catch (e) { console.error('Pull error:', e.message); }
+  });
+
 program.command('list').alias('ls')
-  .description('Short numbered git log')
+  .description('Short numbered git log (oldest → newest)')
   .action(async () => {
-    const { all } = await git.log();
-    all.forEach((c, i) => console.log(`${i+1}. ${c.hash.slice(0,7)} ${c.message}`));
+    const { all } = await safeLog();
+    all.reverse().forEach((c, i) => console.log(`${i+1}. ${c.hash.slice(0,7)} ${c.message}`));
   });
 
 program.command('largelist').alias('ll')
-  .description('Full git log without pager')
+  .description('Full numbered git log (oldest → newest)')
   .action(async () => {
-    console.log(await git.raw(['--no-pager', 'log']));
+    const { all } = await safeLog();
+    all.reverse().forEach((c, i) => {
+      const date = new Date(c.date).toLocaleString();
+      console.log(`${i+1}. ${c.hash.slice(0,7)} | ${date} | ${c.author_name} → ${c.message}`);
+    });
   });
 
 program.command('branch <c> [name]').alias('b')
   .description('Branch from commit/index')
   .action(async (c, name) => {
-    try {
-      const sha = await resolveCommit(c);
-      const br = name || `branch-${sha.slice(0,7)}`;
-      await git.checkout(['-b', br, sha]);
-      console.log(`Switched to branch ${br} at ${sha}`);
-    } catch (e) { console.error(e.message); }
+    try { const sha = await resolveCommit(c); const br = name || `branch-${sha.slice(0,7)}`; await git.checkout(['-b', br, sha]); console.log(`Switched to branch ${br} at ${sha}`); }
+    catch (e) { console.error('Branch error:', e.message); }
   });
 
 program.command('reset <c>').alias('r')
   .description('Reset branch to commit/index')
-  .option('--hard', 'hard reset')
+  .option('--hard','hard reset')
   .action(async (c, opts) => {
-    try {
-      const sha = await resolveCommit(c);
-      const mode = opts.hard ? '--hard' : '--soft';
-      await git.raw(['reset', mode, sha]);
-      console.log(`Reset (${mode}) to ${sha}`);
-    } catch (e) { console.error(e.message); }
+    try { const sha = await resolveCommit(c); const mode = opts.hard? '--hard':'--soft'; await git.raw(['reset', mode, sha]); console.log(`Reset (${mode}) to ${sha}`); }
+    catch (e) { console.error('Reset error:', e.message); }
   });
 
 program.command('revert <c>').alias('rv')
   .description('Revert commit/index safely')
   .action(async (c) => {
-    try {
-      const sha = await resolveCommit(c);
-      await git.revert(sha);
-      console.log(`Reverted ${sha}`);
-    } catch (e) { console.error(e.message); }
+    try { const sha = await resolveCommit(c); await git.revert(sha); console.log(`Reverted ${sha}`); }
+    catch (e) { console.error('Revert error:', e.message); }
   });
 
-program.parse(process.argv);
+program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gims",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Git Made Simple – AI‑powered git helper using Gemini / OpenAI",
   "author": "S41R4J",
   "license": "MIT",
@@ -33,6 +33,7 @@
   },
   "dependencies": {
     "@google/genai": "^1.5.1",
+    "clipboardy": "^3.0.0",
     "commander": "^11.1.0",
     "openai": "^4.0.0",
     "simple-git": "^3.19.1"