Merge pull request #2 from ai-action/feat/cli

Author: remarkablemark

.github/workflows/test.yml

@@ -5,7 +5,7 @@ permissions:
   contents: read
 
 jobs:
-  test:
+  unit:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
@@ -30,3 +30,58 @@ jobs:
         uses: codecov/codecov-action@v6
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+
+  integration:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Use Node.js
+        uses: actions/setup-node@v6
+        with:
+          cache: npm
+          node-version-file: .nvmrc
+
+      - name: Install dependencies
+        run: npm ci --prefer-offline
+
+      - name: Build package
+        run: npm run build
+
+      - name: Setup Ollama
+        uses: ai-action/setup-ollama@v2
+
+      - name: Install CLI
+        run: |
+          package_archive=$(npm pack | tail -n 1)
+          npm install --global "./$package_archive"
+
+      - name: Verify CLI version
+        run: |
+          actual=$(code-ollama --version)
+          printf '%s\n' "$actual"
+          expected="$(node -p "require('./package.json').version")"
+          grep -F "$expected" <<< "$actual"
+
+      - name: Verify CLI help
+        run: |
+          output=$(code-ollama --help)
+          printf '%s\n' "$output"
+          grep -F "code-ollama" <<< "$output"
+          grep -F "run <model> <prompt>" <<< "$output"
+
+      - name: Cache model
+        uses: actions/cache@v5
+        with:
+          path: ~/.ollama
+          key: ${{ runner.os }}-ollama
+
+      - name: Pull model
+        run: ollama pull qwen2.5:0.5b
+
+      - name: Verify CLI run
+        run: |
+          output=$(code-ollama run qwen2.5:0.5b "Repeat exactly this token and nothing else: INTEGRATION_PASS_7F3A")
+          printf '%s\n' "$output"
+          grep -F "INTEGRATION_PASS_7F3A" <<< "$output"

AGENTS.md

@@ -45,6 +45,7 @@ Single-test examples:
 - TypeScript is `strict`; avoid implicit `any`
 - Use barrel files (`index.ts`) to consolidate related exports
 - Use `// v8 ignore` in tests to exclude unreachable entrypoint guards; use `vi.hoisted()` for mock variables accessed by `vi.mock()` hoisted scopes
+- Use Conventional Commits: type(scope): description
 - Create PR with `.github/PULL_REQUEST_TEMPLATE.md`
 
 ## Verification

README.md

@@ -24,7 +24,9 @@ npm install --global code-ollama
 
 ## Usage
 
-Run the CLI:
+### TUI
+
+Open the TUI:
 
 ```sh
 code-ollama
@@ -36,6 +38,27 @@ Or use the alias:
 collama
 ```
 
+### CLI
+
+Show the version:
+
+```sh
+code-ollama --version
+```
+
+Show the help:
+
+```sh
+code-ollama --help
+```
+
+Run a one-off prompt:
+
+```sh
+# code-ollama run <model> <prompt>
+code-ollama run gemma4 "review diff"
+```
+
 ## License
 
 [MIT](https://github.com/ai-action/code-ollama/blob/master/LICENSE)

package.json

@@ -10,7 +10,7 @@
   },
   "scripts": {
     "build": "vite build",
-    "start": "tsx --tsconfig tsconfig.test.json src/cli.tsx",
+    "start": "tsx --tsconfig tsconfig.test.json src/cli.ts",
     "clean": "rm -rf coverage dist docs",
     "lint": "eslint .",
     "lint:fix": "npm run lint -- --fix",

src/cli.test.ts

@@ -1,19 +1,49 @@
 import type { MockInstance } from 'vitest';
 
-const { clearScreen, outputHelp, parse, render } = vi.hoisted(() => ({
+type RunAction = (model: string, prompt: string) => Promise<void>;
+
+const {
+  clearScreen,
+  createSystemMessage,
+  executeTool,
+  outputHelp,
+  parse,
+  renderApp,
+  streamChat,
+} = vi.hoisted(() => ({
   clearScreen: vi.fn(),
+  createSystemMessage: vi.fn(() => ({
+    role: 'system',
+    content: 'system prompt',
+  })),
+  executeTool: vi.fn(),
   outputHelp: vi.fn(),
   parse: vi.fn(),
-  render: vi.fn(),
+  renderApp: vi.fn(),
+  streamChat: vi.fn(),
+}));
+
+const commandState = vi.hoisted(() => ({
+  runAction: null as RunAction | null,
 }));
 
-vi.mock('./utils', () => ({ screen: { clear: clearScreen } }));
-vi.mock('ink', () => ({ render }));
+vi.mock('./utils', () => ({
+  agents: { createSystemMessage },
+  ollama: { streamChat },
+  screen: { clear: clearScreen },
+  tools: { TOOLS: ['mock-tool'], executeTool },
+}));
+vi.mock('./tui', () => ({ renderApp }));
 
 vi.mock('cac', () => ({
   default: () => ({
     version: vi.fn(),
     help: vi.fn(),
+    command: vi.fn(() => ({
+      action: vi.fn((callback: RunAction) => {
+        commandState.runAction = callback;
+      }),
+    })),
     outputHelp,
     parse,
   }),
@@ -23,38 +53,183 @@ import { main } from './cli';
 
 describe('cli', () => {
   let stdoutSpy: MockInstance<typeof process.stdout.write>;
+  let stderrSpy: MockInstance<typeof process.stderr.write>;
 
   beforeEach(() => {
     stdoutSpy = vi
       .spyOn(process.stdout, 'write')
       .mockImplementation(() => true);
+    stderrSpy = vi
+      .spyOn(process.stderr, 'write')
+      .mockImplementation(() => true);
   });
 
   afterEach(() => {
     vi.clearAllMocks();
     stdoutSpy.mockRestore();
+    stderrSpy.mockRestore();
+    process.exitCode = undefined;
   });
 
-  it('renders TUI with no args', () => {
-    main([]);
+  it('renders TUI with no args', async () => {
+    await main([]);
     expect(clearScreen).toHaveBeenCalledOnce();
-    expect(render).toHaveBeenCalledOnce();
+    expect(renderApp).toHaveBeenCalledOnce();
     expect(parse).not.toHaveBeenCalled();
   });
 
-  it('calls parse with --help', () => {
-    main(['--help']);
+  it('calls parse with --help', async () => {
+    await main(['--help']);
     expect(parse).toHaveBeenCalledWith(['node', 'code-ollama', '--help']);
     expect(outputHelp).not.toHaveBeenCalled();
   });
 
-  it('calls parse with --version', () => {
-    main(['--version']);
+  it('calls parse with --version', async () => {
+    await main(['--version']);
     expect(parse).toHaveBeenCalledWith(['node', 'code-ollama', '--version']);
   });
 
-  it('calls parse with -v', () => {
-    main(['-v']);
+  it('calls parse with -v', async () => {
+    await main(['-v']);
     expect(parse).toHaveBeenCalledWith(['node', 'code-ollama', '-v']);
   });
+
+  it('calls parse for run without rendering TUI', async () => {
+    await main(['run', 'gemma4', 'review diff']);
+    expect(renderApp).not.toHaveBeenCalled();
+    expect(parse).toHaveBeenCalledWith([
+      'node',
+      'code-ollama',
+      'run',
+      'gemma4',
+      'review diff',
+    ]);
+  });
+
+  it('streams one-off run output with the provided model', async () => {
+    streamChat.mockImplementationOnce(async function* () {
+      await Promise.resolve();
+      yield { type: 'content', content: 'Review complete.' };
+    });
+
+    await commandState.runAction?.('gemma4', 'review diff');
+
+    expect(createSystemMessage).toHaveBeenCalledOnce();
+    expect(streamChat).toHaveBeenCalledWith(
+      [
+        { role: 'system', content: 'system prompt' },
+        { role: 'user', content: 'review diff' },
+      ],
+      'gemma4',
+      ['mock-tool'],
+    );
+    expect(stdoutSpy).toHaveBeenNthCalledWith(1, 'Review complete.');
+    expect(stdoutSpy).toHaveBeenNthCalledWith(2, '\n');
+  });
+
+  it('executes tool calls and continues the run conversation', async () => {
+    streamChat
+      .mockImplementationOnce(async function* () {
+        await Promise.resolve();
+        yield {
+          type: 'tool_calls',
+          tool_calls: [
+            {
+              function: {
+                name: 'run_shell',
+                arguments: { command: 'git diff --stat' },
+              },
+            },
+          ],
+        };
+      })
+      .mockImplementationOnce(async function* () {
+        await Promise.resolve();
+        yield { type: 'content', content: 'Diff reviewed.' };
+      });
+    executeTool.mockResolvedValueOnce({
+      content: ' src/cli.tsx | 10 +++++++++-',
+    });
+
+    await commandState.runAction?.('gemma4', 'review diff');
+
+    expect(executeTool).toHaveBeenCalledWith('run_shell', {
+      command: 'git diff --stat',
+    });
+    expect(streamChat).toHaveBeenNthCalledWith(
+      2,
+      [
+        { role: 'system', content: 'system prompt' },
+        { role: 'user', content: 'review diff' },
+        { role: 'assistant', content: '' },
+        {
+          role: 'system',
+          content: 'Tool run_shell result:\n src/cli.tsx | 10 +++++++++-',
+        },
+      ],
+      'gemma4',
+      ['mock-tool'],
+    );
+    expect(stdoutSpy).toHaveBeenNthCalledWith(1, 'Diff reviewed.');
+    expect(stdoutSpy).toHaveBeenNthCalledWith(2, '\n');
+  });
+
+  it('includes tool execution errors in the follow-up run conversation', async () => {
+    streamChat
+      .mockImplementationOnce(async function* () {
+        await Promise.resolve();
+        yield {
+          type: 'tool_calls',
+          tool_calls: [
+            {
+              function: {
+                name: 'run_shell',
+                arguments: { command: 'git diff --stat' },
+              },
+            },
+          ],
+        };
+      })
+      .mockImplementationOnce(async function* () {
+        await Promise.resolve();
+        yield { type: 'content', content: 'Tool error handled.' };
+      });
+    executeTool.mockResolvedValueOnce({
+      content: 'partial output',
+      error: 'shell failed',
+    });
+
+    await commandState.runAction?.('gemma4', 'review diff');
+
+    expect(streamChat).toHaveBeenNthCalledWith(
+      2,
+      [
+        { role: 'system', content: 'system prompt' },
+        { role: 'user', content: 'review diff' },
+        { role: 'assistant', content: '' },
+        {
+          role: 'system',
+          content:
+            'Tool run_shell result:\npartial output\nError: shell failed',
+        },
+      ],
+      'gemma4',
+      ['mock-tool'],
+    );
+    expect(stdoutSpy).toHaveBeenNthCalledWith(1, 'Tool error handled.');
+    expect(stdoutSpy).toHaveBeenNthCalledWith(2, '\n');
+  });
+
+  it('reports run errors and sets exit code', async () => {
+    streamChat.mockImplementationOnce(async function* () {
+      await Promise.resolve();
+      throw new Error('Ollama unavailable');
+      yield { type: 'content', content: '' };
+    });
+
+    await commandState.runAction?.('gemma4', 'review diff');
+
+    expect(stderrSpy).toHaveBeenCalledWith('Error: Ollama unavailable\n');
+    expect(process.exitCode).toBe(1);
+  });
 });