agcel 1.0.1

package/.agent/workflows/test.md

@@ -0,0 +1,340 @@
+# /test - Test Generation Command
+
+## Purpose
+
+Generate comprehensive tests for specified code including unit tests, integration tests, and edge cases.
+
+## Usage
+
+```
+/test [file path | function name | 'coverage' | 'all']
+```
+
+## Arguments
+
+- `$ARGUMENTS`:
+  - File path: Generate tests for specific file
+  - Function name: Generate tests for specific function
+  - `coverage`: Analyze and improve test coverage
+  - `all`: Run all tests and report results
+
+---
+
+Generate comprehensive tests for: **$ARGUMENTS**
+
+## Workflow
+
+### For File/Function Testing
+
+1. **Analyze Target Code**
+   - Read the code to understand functionality
+   - Identify inputs, outputs, and side effects
+   - Note dependencies to mock
+   - Find existing tests for patterns
+
+2. **Design Test Cases**
+   - **Happy Path**: Normal operation with valid inputs
+   - **Edge Cases**: Boundary values, empty inputs, limits
+   - **Error Cases**: Invalid inputs, exceptions
+   - **Integration Points**: External dependencies
+
+3. **Generate Tests**
+   - Follow project testing conventions
+   - Use appropriate mocking strategies
+   - Write clear, descriptive test names
+   - Include setup and teardown
+
+4. **Run and Verify**
+   ```bash
+   # Python
+   pytest [test_file] -v
+
+   # TypeScript
+   pnpm test [test_file]
+   ```
+
+### For Coverage Analysis
+
+1. **Run Coverage Report**
+   ```bash
+   # Python
+   pytest --cov=src --cov-report=term-missing
+
+   # TypeScript
+   pnpm test --coverage
+   ```
+
+2. **Identify Gaps**
+   - Find untested functions
+   - Identify untested branches
+   - Note missing edge cases
+
+3. **Generate Missing Tests**
+   - Prioritize by risk
+   - Focus on critical paths
+   - Add edge case coverage
+
+## Test Templates
+
+### Python (pytest)
+
+```python
+import pytest
+from unittest.mock import Mock, patch
+from src.module import function_under_test
+
+class TestFunctionUnderTest:
+    """Tests for function_under_test."""
+
+    def test_with_valid_input_returns_expected(self):
+        """Test that valid input produces expected output."""
+        result = function_under_test("valid_input")
+        assert result == "expected_output"
+
+    def test_with_empty_input_returns_default(self):
+        """Test that empty input returns default value."""
+        result = function_under_test("")
+        assert result == "default"
+
+    def test_with_invalid_input_raises_error(self):
+        """Test that invalid input raises ValueError."""
+        with pytest.raises(ValueError, match="Invalid input"):
+            function_under_test(None)
+
+    @pytest.mark.parametrize("input_val,expected", [
+        ("a", "result_a"),
+        ("b", "result_b"),
+        ("c", "result_c"),
+    ])
+    def test_parametrized_inputs(self, input_val, expected):
+        """Test multiple input variations."""
+        assert function_under_test(input_val) == expected
+
+    @patch('src.module.external_service')
+    def test_with_mocked_dependency(self, mock_service):
+        """Test with mocked external dependency."""
+        mock_service.call.return_value = "mocked_result"
+        result = function_under_test("input")
+        assert result == "expected_with_mock"
+        mock_service.call.assert_called_once_with("input")
+```
+
+### TypeScript (vitest)
+
+```typescript
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { functionUnderTest } from './module';
+
+describe('functionUnderTest', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return expected output for valid input', () => {
+    const result = functionUnderTest('valid_input');
+    expect(result).toBe('expected_output');
+  });
+
+  it('should return default for empty input', () => {
+    const result = functionUnderTest('');
+    expect(result).toBe('default');
+  });
+
+  it('should throw error for invalid input', () => {
+    expect(() => functionUnderTest(null)).toThrow('Invalid input');
+  });
+
+  it.each([
+    ['a', 'result_a'],
+    ['b', 'result_b'],
+    ['c', 'result_c'],
+  ])('should handle input %s correctly', (input, expected) => {
+    expect(functionUnderTest(input)).toBe(expected);
+  });
+
+  it('should work with mocked dependency', async () => {
+    vi.mock('./external-service', () => ({
+      call: vi.fn().mockResolvedValue('mocked_result'),
+    }));
+
+    const result = await functionUnderTest('input');
+    expect(result).toBe('expected_with_mock');
+  });
+});
+```
+
+### React Component (Testing Library)
+
+```typescript
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { UserForm } from './UserForm';
+
+describe('UserForm', () => {
+  it('should render form fields', () => {
+    render(<UserForm onSubmit={vi.fn()} />);
+
+    expect(screen.getByLabelText(/name/i)).toBeInTheDocument();
+    expect(screen.getByLabelText(/email/i)).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /submit/i })).toBeInTheDocument();
+  });
+
+  it('should call onSubmit with form data', async () => {
+    const onSubmit = vi.fn();
+    render(<UserForm onSubmit={onSubmit} />);
+
+    fireEvent.change(screen.getByLabelText(/name/i), {
+      target: { value: 'John' },
+    });
+    fireEvent.change(screen.getByLabelText(/email/i), {
+      target: { value: 'john@example.com' },
+    });
+    fireEvent.click(screen.getByRole('button', { name: /submit/i }));
+
+    await waitFor(() => {
+      expect(onSubmit).toHaveBeenCalledWith({
+        name: 'John',
+        email: 'john@example.com',
+      });
+    });
+  });
+
+  it('should show validation error for invalid email', async () => {
+    render(<UserForm onSubmit={vi.fn()} />);
+
+    fireEvent.change(screen.getByLabelText(/email/i), {
+      target: { value: 'invalid' },
+    });
+    fireEvent.blur(screen.getByLabelText(/email/i));
+
+    expect(await screen.findByText(/invalid email/i)).toBeInTheDocument();
+  });
+});
+```
+
+## Output
+
+### Test Generation Report
+
+```markdown
+## Tests Generated
+
+### Target
+`src/services/auth.ts` - AuthService class
+
+### Tests Created
+- `tests/services/auth.test.ts`
+
+### Test Cases
+1. `login_with_valid_credentials_returns_token` - Happy path
+2. `login_with_invalid_password_throws_error` - Error case
+3. `login_with_nonexistent_user_throws_error` - Error case
+4. `refresh_token_with_valid_token_returns_new_token` - Happy path
+5. `refresh_token_with_expired_token_throws_error` - Edge case
+6. `logout_invalidates_session` - Happy path
+
+### Coverage Impact
+- Before: 65%
+- After: 88%
+- New lines covered: 42
+
+### Run Tests
+```bash
+pytest tests/services/auth.test.ts -v
+```
+
+### Notes
+- Mocked database calls using pytest-mock
+- Added edge case for token expiration
+- Consider adding integration tests for full auth flow
+```
+
+## Flags
+
+| Flag | Description | Example |
+|------|-------------|---------|
+| `--coverage` | Generate coverage-focused tests | `--coverage` |
+| `--type=[type]` | Test type to generate | `--type=integration` |
+| `--format=[fmt]` | Output format (concise/detailed) | `--format=concise` |
+| `--framework=[fw]` | Specify test framework | `--framework=vitest` |
+| `--tdd` | Generate TDD-style with failing tests first | `--tdd` |
+| `--edge-cases` | Focus on edge case coverage | `--edge-cases` |
+
+### Flag Usage Examples
+
+```bash
+/test --coverage src/services/
+/test --type=integration src/api/users.ts
+/test --tdd src/utils/validator.ts
+/test --edge-cases --framework=pytest src/models/user.py
+```
+
+### Test Types
+
+| Type | Description |
+|------|-------------|
+| `unit` | Isolated function tests (default) |
+| `integration` | Multi-component tests |
+| `e2e` | End-to-end workflow tests |
+| `snapshot` | Snapshot tests for UI |
+| `property` | Property-based testing |
+
+### Framework Options
+
+| Framework | Language |
+|-----------|----------|
+| `pytest` | Python |
+| `vitest` | TypeScript/JavaScript |
+| `jest` | JavaScript |
+| `playwright` | E2E (any) |
+
+## MCP Integration
+
+This command leverages MCP servers for enhanced testing:
+
+### Browser tools - E2E Testing (Primary for UI)
+```
+For E2E and browser tests:
+- Use Browser tools for cross-browser testing
+- Automate user flow verification
+- Capture screenshots for visual testing
+- Test on different device emulations
+```
+
+### Filesystem - Test File Management
+```
+For test file operations:
+- Use list_dir to find test directories
+- Use grep_search to find existing tests
+- Use view_file to check test patterns
+- Use write_to_file to create new test files
+```
+
+### Web Search - Testing Best Practices
+```
+For framework-specific testing:
+- Fetch current testing library docs
+- Get latest assertions and matchers
+- Find recommended testing patterns
+```
+
+### Memory - Test Patterns
+```
+Recall testing context:
+- Remember project testing conventions
+- Recall mock patterns used previously
+- Store common test fixtures
+```
+
+<!-- CUSTOMIZATION POINT -->
+## Variations
+
+Modify behavior via CLAUDE.md:
+- Preferred test framework
+- Minimum coverage targets
+- Test naming conventions
+- Required test categories
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/.agent/workflows/verify.md

@@ -0,0 +1,35 @@
+---
+description: Verification, Testing, and Auditing
+---
+
+# /verify Workflow
+
+This workflow audits the codebase for bugs, quality issues, and security vulnerabilities.
+
+## Steps
+
+1.  **Static Analysis & Audit**
+    - Use key: `code-auditing`
+    - Goal: General code quality review and linting.
+    - Output: List of code style issues or potential bugs.
+
+2.  **Security Scan**
+    - Use key: `vulnerability-scanner`
+    - Goal: Scan dependencies and code patterns for known vulnerabilities.
+    - Instruction: Check `package.json` / `requirements.txt` against known CVE databases (simulated).
+
+3.  **SQL Injection Check**
+    - Use key: `sql-injection-testing`
+    - Goal: Specifically check database queries for injection risks.
+
+4.  **Test Verification**
+    - Use key: `qa-engineer` / `test-fixing`
+    - Goal: Run all tests and attempt to fix any failures.
+    - Instruction: Ensure all tests pass before completing the workflow.
+
+## Iron Rules
+1. If there is anything unclear, ask the user instead of inventing new stuff. Unless the user explicitly tells the AI to invent or suggest ideas.
+
+
+## Gap Analysis Rule
+Always identify gaps and suggest next steps to users. In case there is no gaps anymore, then AI should clearly state that there is no gap left.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bennie Ng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+# AgCel
+
+AgCel is a local MCP (Model Context Protocol) Skills Server that functions both as a command-line tool and a backend for Antigravity workflows. It bridges the gap between local execution and AI agent capabilities by providing structured "Skills".
+
+## Overview
+
+The project consists of two main components:
+1.  **AgCel CLI**: A command-line interface to manage and interact with the MCP server.
+2.  **AgCel MCP Skills Server**: A local server that hosts skills and capabilities, enabling AI agents to perform complex tasks.
+
+## Installation
+
+To install the AgCel CLI globally and set up the local MCP server:
+
+```bash
+npx agcel install
+```
+
+## CLI Usage
+
+The `agc` command-line tool is your primary interface. Application data is stored in the `.agc` directory in your project root, and `~/.agcel` for global configuration.
+
+| Command | Description |
+| :--- | :--- |
+| `agc start` | Start the MCP server locally. |
+| `agc stop` | Stop the running MCP server. |
+| `agc restart` | Restart the MCP server. |
+| `agc status` | Check the status of the local MCP server. |
+| `agc init` | Initialize AgCel in the current project (copies workflows to `.agent/workflows`). |
+| `agc skills list` | List all available skills. |
+| `agc workflows list` | List all available workflows. |
+| `agc --help` | Show the help menu. |
+| `agc --version` | Show the CLI version. |
+
+## Concepts
+
+### Skills
+
+**Skills** are specialized capabilities that allow the AI to perform complex tasks. AgCel comes with a rich set of built-in skills:
+
+-   **Languages**: Python, TypeScript, JavaScript
+-   **Frameworks**: React, Next.js, FastAPI, Django
+-   **DevOps**: Docker, GitHub Actions, Vercel
+-   **Security**: OWASP, Vulnerability Scanning
+-   **Methodology**: TDD, Systematic Debugging, Code Review, Architecture
+
+### Workflows
+
+**Workflows** are standard operating procedures for common development tasks.
+
+-   **Development**: `/feature`, `/fix`, `/test`, `/refactor`
+-   **Planning**: `/plan`, `/brainstorm`, `/research`
+-   **Operations**: `/ship`, `/deploy`, `/security-scan`
+
+### Rules
+
+**Rules** serve as guardrails for the AI.
+
+-   **Boundary Rules**: "Do not use external libraries."
+-   **Operational Rules**: "Always ask for clarification."
+-   **Security Rules**: "Never share API keys."
+
+## Integration with Antigravity
+
+When working with the Antigravity IDE:
+1.  Run `agc init` to set up the environment.
+2.  Use workflows in the Agent Window (e.g., `/agc idea` for ideation).

package/dist/commands/init.js

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const index_js_1 = require("../utils/index.js");
+async function initCommand() {
+    const globalDir = (0, index_js_1.getGlobalAgCelDir)();
+    const globalWorkflowsDir = path_1.default.join(globalDir, 'workflows');
+    console.log(chalk_1.default.blue('Initializing AgCel in current project...'));
+    // 1. Check if global install exists
+    if (!fs_1.default.existsSync(globalDir)) {
+        console.error(chalk_1.default.red('Error: AgCel is not installed globally.'));
+        console.error(chalk_1.default.yellow('Please run "npx agcel install" first to set up the global environment.'));
+        return;
+    }
+    if (!fs_1.default.existsSync(globalWorkflowsDir)) {
+        console.error(chalk_1.default.red(`Error: Workflows directory not found in global install at ${globalWorkflowsDir}`));
+        console.error(chalk_1.default.yellow('Please try running "npx agcel install" again to fix the installation.'));
+        return;
+    }
+    // 2. Setup local .agc and .agent directories
+    const projectAgcDir = path_1.default.join(process.cwd(), '.agc');
+    const projectSkillsDir = path_1.default.join(projectAgcDir, 'skills');
+    const projectAgentDir = path_1.default.join(process.cwd(), '.agent');
+    const projectWorkflowsDir = path_1.default.join(projectAgentDir, 'workflows');
+    // Create .agc directory (Critical for isInitialized check)
+    if (!fs_1.default.existsSync(projectAgcDir)) {
+        console.log(chalk_1.default.blue('Creating .agc directory...'));
+        fs_1.default.mkdirSync(projectAgcDir, { recursive: true });
+    }
+    // Copy skills from global install to .agc/skills
+    const globalSkillsDir = path_1.default.join(globalDir, 'skills');
+    if (fs_1.default.existsSync(globalSkillsDir)) {
+        if (!fs_1.default.existsSync(projectSkillsDir)) {
+            console.log(chalk_1.default.blue('Creating .agc/skills directory...'));
+            fs_1.default.mkdirSync(projectSkillsDir, { recursive: true });
+        }
+        console.log(chalk_1.default.blue('Copying skills...'));
+        fs_1.default.cpSync(globalSkillsDir, projectSkillsDir, { recursive: true });
+    }
+    else {
+        console.warn(chalk_1.default.yellow(`Warning: Global skills not found at ${globalSkillsDir}`));
+    }
+    try {
+        if (!fs_1.default.existsSync(projectAgentDir)) {
+            console.log(chalk_1.default.blue('Creating .agent directory...'));
+            fs_1.default.mkdirSync(projectAgentDir, { recursive: true });
+        }
+        if (!fs_1.default.existsSync(projectWorkflowsDir)) {
+            console.log(chalk_1.default.blue('Creating .agent/workflows directory...'));
+            fs_1.default.mkdirSync(projectWorkflowsDir, { recursive: true });
+        }
+        // 3. Copy workflows
+        console.log(chalk_1.default.blue('Copying workflows...'));
+        const workflows = fs_1.default.readdirSync(globalWorkflowsDir);
+        let overwriteAll = false;
+        for (const workflow of workflows) {
+            const srcPath = path_1.default.join(globalWorkflowsDir, workflow);
+            const destPath = path_1.default.join(projectWorkflowsDir, workflow);
+            if (fs_1.default.lstatSync(srcPath).isFile()) {
+                const content = fs_1.default.readFileSync(srcPath, 'utf-8');
+                if (fs_1.default.existsSync(destPath)) {
+                    const destContent = fs_1.default.readFileSync(destPath, 'utf-8');
+                    if (content !== destContent) {
+                        let action = 'skip';
+                        if (overwriteAll) {
+                            action = 'overwrite';
+                        }
+                        else {
+                            const answer = await inquirer_1.default.prompt([{
+                                    type: 'expand',
+                                    name: 'action',
+                                    message: `Workflow ${workflow} already exists and is different.`,
+                                    choices: [
+                                        { key: 'y', name: 'Overwrite', value: 'overwrite' },
+                                        { key: 'n', name: 'Skip', value: 'skip' },
+                                        { key: 'a', name: 'Overwrite All', value: 'all' }
+                                    ],
+                                    default: 1
+                                }]);
+                            if (answer.action === 'all') {
+                                overwriteAll = true;
+                                action = 'overwrite';
+                            }
+                            else {
+                                action = answer.action;
+                            }
+                        }
+                        if (action === 'overwrite') {
+                            fs_1.default.writeFileSync(destPath, content);
+                            console.log(chalk_1.default.green(`Updated ${workflow}`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow(`Skipped ${workflow}`));
+                        }
+                    }
+                }
+                else {
+                    fs_1.default.writeFileSync(destPath, content);
+                    console.log(chalk_1.default.green(`Created ${workflow}`));
+                }
+            }
+        }
+        console.log(chalk_1.default.green('AgCel project initialization complete!'));
+        console.log(chalk_1.default.cyan('Workflows installed to .agent/workflows'));
+        console.log(chalk_1.default.cyan('Skills installed to .agc/skills'));
+        // 4. Update .gitignore
+        updateGitIgnore(process.cwd());
+    }
+    catch (error) {
+        throw error; // Re-throw to be caught by outer catch
+    }
+}
+function updateGitIgnore(cwd) {
+    const gitIgnorePath = path_1.default.join(cwd, '.gitignore');
+    const entriesToAdd = ['.agc', '.agents', '.agent'];
+    let content = '';
+    if (fs_1.default.existsSync(gitIgnorePath)) {
+        content = fs_1.default.readFileSync(gitIgnorePath, 'utf-8');
+    }
+    else {
+        console.log(chalk_1.default.blue('Creating .gitignore...'));
+    }
+    const lines = content.split('\n').map(line => line.trim());
+    const newEntries = [];
+    for (const entry of entriesToAdd) {
+        if (!lines.includes(entry)) {
+            newEntries.push(entry);
+        }
+    }
+    if (newEntries.length > 0) {
+        const appendContent = (content && !content.endsWith('\n') ? '\n' : '') + newEntries.join('\n') + '\n';
+        fs_1.default.appendFileSync(gitIgnorePath, appendContent);
+        console.log(chalk_1.default.green(`Added ${newEntries.join(', ')} to .gitignore`));
+    }
+}