eckra 1.0.0

package/src/ui/status.js

@@ -0,0 +1,156 @@
+const chalk = require("chalk");
+const Table = require("cli-table3");
+const boxen = require("boxen");
+const {
+  getGitStatus,
+  getCurrentBranch,
+  getRemotes,
+} = require("../helpers/git");
+
+async function showStatus() {
+  const status = await getGitStatus();
+  const remotes = await getRemotes();
+
+  console.log("\n");
+
+  // Branch info
+  console.log(
+    boxen(
+      chalk.cyan("🌿 Branch: ") +
+      chalk.yellow.bold(status.current) +
+      (status.tracking ? chalk.gray(` → ${status.tracking}`) : "") +
+      (status.ahead ? chalk.green(` ↑${status.ahead}`) : "") +
+      (status.behind ? chalk.red(` ↓${status.behind}`) : ""),
+      {
+        padding: { left: 2, right: 2, top: 0, bottom: 0 },
+        borderStyle: "round",
+        borderColor: "cyan",
+      },
+    ),
+  );
+
+  // Staged files
+  if (status.staged.length > 0) {
+    console.log(
+      chalk.green.bold("\n✓ Staged Files (ready to commit):"),
+    );
+    const stagedTable = new Table({
+      head: [chalk.green("File"), chalk.green("Status")],
+      colWidths: [50, 15],
+      style: { head: [], border: ["gray"] },
+    });
+
+    status.staged.forEach((file) => {
+      let fileStatus = "modified";
+      if (status.created.includes(file)) fileStatus = "new file";
+      if (status.deleted.includes(file)) fileStatus = "deleted";
+      if (status.renamed.includes(file)) fileStatus = "renamed";
+
+      stagedTable.push([chalk.green(file), chalk.green(fileStatus)]);
+    });
+
+    console.log(stagedTable.toString());
+  }
+
+  // Modified files (not staged)
+  if (status.modified.length > 0 || status.deleted.length > 0) {
+    console.log(
+      chalk.red.bold("\n● Modified Files (not staged):"),
+    );
+    const modifiedTable = new Table({
+      head: [chalk.red("File"), chalk.red("Status")],
+      colWidths: [50, 15],
+      style: { head: [], border: ["gray"] },
+    });
+
+    status.modified.forEach((file) => {
+      if (!status.staged.includes(file)) {
+        modifiedTable.push([chalk.red(file), chalk.red("modified")]);
+      }
+    });
+
+    status.deleted.forEach((file) => {
+      if (!status.staged.includes(file)) {
+        modifiedTable.push([chalk.red(file), chalk.red("deleted")]);
+      }
+    });
+
+    if (modifiedTable.length > 0) {
+      console.log(modifiedTable.toString());
+    }
+  }
+
+  // Untracked files
+  if (status.not_added.length > 0) {
+    console.log(chalk.blue.bold("\n? Untracked Files:"));
+    const untrackedTable = new Table({
+      head: [chalk.blue("File")],
+      colWidths: [65],
+      style: { head: [], border: ["gray"] },
+    });
+
+    status.not_added.forEach((file) => {
+      untrackedTable.push([chalk.blue(file)]);
+    });
+
+    console.log(untrackedTable.toString());
+  }
+
+  // Conflicted files
+  if (status.conflicted.length > 0) {
+    console.log(chalk.yellow.bold("\n⚠️  Conflicted Files:"));
+    const conflictTable = new Table({
+      head: [chalk.yellow("File")],
+      colWidths: [65],
+      style: { head: [], border: ["gray"] },
+    });
+
+    status.conflicted.forEach((file) => {
+      conflictTable.push([chalk.yellow(file)]);
+    });
+
+    console.log(conflictTable.toString());
+  }
+
+  // Summary
+  const totalChanges =
+    status.staged.length + status.modified.length + status.not_added.length;
+
+  if (totalChanges === 0) {
+    console.log(
+      boxen(
+        chalk.green(
+          "✨ Working directory clean - nothing to commit.",
+        ),
+        { padding: 1, borderStyle: "round", borderColor: "green" },
+      ),
+    );
+  } else {
+    console.log(chalk.gray("\n─".repeat(40)));
+    console.log(
+      chalk.white("Summary: ") +
+      chalk.green(`${status.staged.length} staged`) +
+      chalk.gray(" | ") +
+      chalk.red(`${status.modified.length} modified`) +
+      chalk.gray(" | ") +
+      chalk.blue(`${status.not_added.length} untracked`),
+    );
+  }
+
+  // Remote info
+  if (remotes.length > 0) {
+    console.log(chalk.gray("\n📡 Remotes:"));
+    remotes.forEach((remote) => {
+      console.log(
+        chalk.gray(`   ${remote.name}: `) +
+        chalk.white(remote.refs.fetch || remote.refs.push),
+      );
+    });
+  }
+
+  console.log("\n");
+}
+
+module.exports = {
+  showStatus,
+};

package/tests/ai.test.js

@@ -0,0 +1,112 @@
+const axios = require('axios');
+const { generateCommitMessage } = require('../src/helpers/ai');
+const configHelper = require('../src/helpers/config');
+
+jest.mock('axios');
+jest.mock('../src/helpers/config');
+
+describe('AI Helper', () => {
+  const mockDiff = 'diff content';
+  const mockFiles = ['file1.js'];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should call OpenAI API correctly', async () => {
+    configHelper.getConfig.mockReturnValue({
+      aiProvider: 'openai',
+      openaiApiKey: 'sk-test',
+      openaiModel: 'gpt-4o'
+    });
+
+    axios.post.mockResolvedValue({
+      data: {
+        choices: [{ message: { content: 'feat: openai commit' } }]
+      }
+    });
+
+    const message = await generateCommitMessage(mockDiff, mockFiles);
+
+    expect(message).toBe('feat: openai commit');
+    expect(axios.post).toHaveBeenCalledWith(
+      'https://api.openai.com/v1/chat/completions',
+      expect.objectContaining({
+        model: 'gpt-4o',
+        messages: expect.any(Array)
+      }),
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'Authorization': 'Bearer sk-test'
+        })
+      })
+    );
+  });
+
+  test('should call Anthropic API correctly', async () => {
+    configHelper.getConfig.mockReturnValue({
+      aiProvider: 'anthropic',
+      anthropicApiKey: 'sk-ant-test',
+      anthropicModel: 'claude-3'
+    });
+
+    axios.post.mockResolvedValue({
+      data: {
+        content: [{ text: 'feat: anthropic commit' }]
+      }
+    });
+
+    const message = await generateCommitMessage(mockDiff, mockFiles);
+
+    expect(message).toBe('feat: anthropic commit');
+    expect(axios.post).toHaveBeenCalledWith(
+      'https://api.anthropic.com/v1/messages',
+      expect.objectContaining({
+        model: 'claude-3',
+        system: expect.any(String) // System prompt is separate in Anthropic
+      }),
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-api-key': 'sk-ant-test'
+        })
+      })
+    );
+  });
+
+  test('should call Ollama API correctly', async () => {
+    configHelper.getConfig.mockReturnValue({
+      aiProvider: 'ollama',
+      ollamaUrl: 'http://localhost:11434',
+      ollamaModel: 'llama3'
+    });
+
+    axios.post.mockResolvedValue({
+      data: {
+        message: { content: 'feat: ollama commit' }
+      }
+    });
+
+    const message = await generateCommitMessage(mockDiff, mockFiles);
+
+    expect(message).toBe('feat: ollama commit');
+    expect(axios.post).toHaveBeenCalledWith(
+      'http://localhost:11434/api/chat',
+      expect.objectContaining({
+        model: 'llama3',
+        stream: false
+      }),
+      expect.any(Object)
+    );
+  });
+
+  test('should handle API errors gracefully', async () => {
+    configHelper.getConfig.mockReturnValue({ aiProvider: 'openai' });
+    
+    axios.post.mockRejectedValue({
+      response: { status: 401, data: { error: 'Unauthorized' } }
+    });
+
+    await expect(generateCommitMessage(mockDiff, mockFiles))
+      .rejects.toThrow('AI Provider Error (openai): 401');
+  });
+});

package/tests/config.test.js

@@ -0,0 +1,123 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getConfig, DEFAULT_CONFIG } = require('../src/helpers/config');
+
+// Mock fs to avoid touching real files
+jest.mock('fs');
+
+describe('Config Helper', () => {
+  const MOCK_HOMEDIR = '/mock/home';
+  const MOCK_CWD = '/mock/project';
+
+  beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    
+    // Mock os.homedir
+    jest.spyOn(os, 'homedir').mockReturnValue(MOCK_HOMEDIR);
+    
+    // Mock process.cwd
+    jest.spyOn(process, 'cwd').mockReturnValue(MOCK_CWD);
+
+    // Default fs behavior
+    fs.existsSync.mockReturnValue(false);
+    fs.mkdirSync.mockImplementation(() => {});
+    fs.readFileSync.mockImplementation(() => '');
+  });
+
+  test('should return default config when no config files exist', () => {
+    const config = getConfig();
+    expect(config).toEqual(DEFAULT_CONFIG);
+  });
+
+  test('should merge global config correctly', () => {
+    const globalConfig = {
+      model: 'global-model-v1',
+      lmStudioUrl: 'http://global-url:1234'
+    };
+
+    // Setup mocks for global config presence
+    fs.existsSync.mockImplementation((filePath) => {
+      if (filePath.includes('.eckra') && filePath.includes('config.json')) return true;
+      return false;
+    });
+
+    fs.readFileSync.mockImplementation((filePath) => {
+      if (filePath.includes('.eckra') && filePath.includes('config.json')) {
+        return JSON.stringify(globalConfig);
+      }
+      return '';
+    });
+
+    const config = getConfig();
+    
+    expect(config.model).toBe(globalConfig.model);
+    expect(config.lmStudioUrl).toBe(globalConfig.lmStudioUrl);
+    // Should verify other defaults remain
+    expect(config.language).toBe(DEFAULT_CONFIG.language);
+  });
+
+  test('should prioritize local .eckrarc over global config', () => {
+    const globalConfig = {
+      model: 'global-model',
+      aiProvider: 'lmstudio'
+    };
+
+    const localConfig = {
+      model: 'local-model',
+      aiProvider: 'openai'
+    };
+
+    // Setup mocks for both files
+    fs.existsSync.mockImplementation((filePath) => {
+      // Global config
+      if (filePath.includes('.eckra') && filePath.includes('config.json')) return true;
+      // Local config in CWD
+      if (filePath === path.join(MOCK_CWD, '.eckrarc')) return true;
+      return false;
+    });
+
+    fs.readFileSync.mockImplementation((filePath) => {
+      if (filePath.includes('config.json')) return JSON.stringify(globalConfig);
+      if (filePath.includes('.eckrarc')) return JSON.stringify(localConfig);
+      return '';
+    });
+
+    const config = getConfig();
+
+    expect(config.model).toBe(localConfig.model);
+    expect(config.aiProvider).toBe(localConfig.aiProvider);
+    expect(config.language).toBe(DEFAULT_CONFIG.language);
+  });
+
+  test('should look for .eckrarc in parent directories', () => {
+    const parentDir = path.dirname(MOCK_CWD);
+    const localConfig = { aiInstruction: 'parent instruction' };
+
+    // Update cwd mock to be a subdir
+    jest.spyOn(process, 'cwd').mockReturnValue(MOCK_CWD);
+
+    // Setup mocks
+    fs.existsSync.mockImplementation((filePath) => {
+      // Not in CWD
+      if (filePath === path.join(MOCK_CWD, '.eckrarc')) return false;
+      // Found in Parent
+      if (filePath === path.join(parentDir, '.eckrarc')) return true;
+      return false;
+    });
+
+    fs.readFileSync.mockImplementation((filePath) => {
+      if (filePath === path.join(parentDir, '.eckrarc')) return JSON.stringify(localConfig);
+      return '';
+    });
+
+    // We need to mock path.dirname to actually traverse up in our mocked environment logic if needed,
+    // but getConfig uses real path module. Ideally we rely on real path behavior or mock carefully.
+    // The getConfig implementation uses a while loop with path.dirname.
+    // Since we are mocking fs, we just need to ensure the loop calls fs.existsSync with the parent path.
+    
+    const config = getConfig();
+    expect(config.aiInstruction).toBe(localConfig.aiInstruction);
+  });
+});

package/tests/patch.test.js

@@ -0,0 +1,44 @@
+const { parseDiff, generatePatch } = require('../src/helpers/patch');
+
+describe('Patch Helper', () => {
+  const mockDiff = `diff --git a/test.js b/test.js
+index 1234567..89abcdef 100644
+--- a/test.js
++++ b/test.js
+@@ -1,3 +1,4 @@
+ line 1
++added line
+ line 2
+ line 3
+@@ -10,3 +11,3 @@
+ old line
+-removed line
++new line
+ other line`;
+
+  test('should parse diff into hunks correctly', () => {
+    const files = parseDiff(mockDiff);
+    
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('test.js');
+    expect(files[0].hunks).toHaveLength(2);
+    
+    expect(files[0].hunks[0].header).toContain('@@ -1,3 +1,4 @@');
+    expect(files[0].hunks[1].header).toContain('@@ -10,3 +11,3 @@');
+  });
+
+  test('should generate patch for selected hunks', () => {
+    const files = parseDiff(mockDiff);
+    const patch = generatePatch(files[0], [0]); // Only first hunk
+    
+    expect(patch).toContain('@@ -1,3 +1,4 @@');
+    expect(patch).not.toContain('@@ -10,3 +11,3 @@');
+    expect(patch).toContain('+added line');
+    expect(patch).not.toContain('-removed line');
+  });
+
+  test('should handle empty diffs', () => {
+    const files = parseDiff('');
+    expect(files).toHaveLength(0);
+  });
+});