claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/tooling-git.md

@@ -0,0 +1,79 @@
+# Git Workflows
+
+## Overview
+Branch strategies, commit conventions, and team workflows for effective version control.
+
+## Conventional Commits
+
+```bash
+# Format: <type>(<scope>): <description>
+git commit -m "feat(auth): add magic link authentication"
+git commit -m "fix(api): handle null user in session middleware"
+git commit -m "chore: update dependencies"
+git commit -m "docs: add API authentication guide"
+git commit -m "refactor(db): extract user repository pattern"
+git commit -m "test(auth): add integration tests for login flow"
+git commit -m "perf(queries): add index on user email column"
+```
+
+## Feature Branch Workflow
+
+```bash
+# Create feature branch from main
+git checkout main && git pull origin main
+git checkout -b feat/user-authentication
+
+# Work and commit
+git add src/auth/
+git commit -m "feat(auth): implement JWT token generation"
+
+# Keep branch updated
+git fetch origin main
+git rebase origin/main  # or merge
+
+# Push for PR
+git push -u origin feat/user-authentication
+```
+
+## Git Aliases (useful shortcuts)
+
+```bash
+git config --global alias.st "status -sb"
+git config --global alias.lg "log --oneline --graph --decorate --all"
+git config --global alias.undo "reset HEAD~1 --mixed"
+git config --global alias.amend "commit --amend --no-edit"
+git config --global alias.br "branch --sort=-committerdate"
+git config --global alias.save "!git add -A && git commit -m 'SAVEPOINT'"
+```
+
+## Commit Message Hook (commitlint)
+
+```bash
+npm install -D @commitlint/cli @commitlint/config-conventional
+echo "export default { extends: ['@commitlint/config-conventional'] };" > commitlint.config.js
+echo "npx commitlint --edit $1" > .husky/commit-msg
+```
+
+## Git Flow Commands
+
+```bash
+# Start a release
+git checkout -b release/1.2.0 main
+npm version minor  # bumps package.json to 1.2.0
+
+# Hotfix
+git checkout -b hotfix/fix-login-crash main
+git commit -m "fix: resolve null pointer in auth middleware"
+git checkout main && git merge hotfix/fix-login-crash --no-ff
+git tag -a v1.2.1 -m "Hotfix: login crash"
+```
+
+## Best Practices
+- Use conventional commits for automated changelogs
+- Squash commits before merging feature branches
+- Protect `main` branch — require PRs and CI checks
+- Write imperative commit messages: "Add feature" not "Added feature"
+
+## Resources
+- [Conventional Commits](https://www.conventionalcommits.org)
+- [Pro Git book](https://git-scm.com/book)

package/kit/.claude/skills/tooling-monorepo.md

@@ -0,0 +1,162 @@
+# Monorepo Management
+
+Organizing multiple related projects in a single repository.
+
+## Turborepo Setup
+
+```bash
+npm install -D turbo
+npx turbo init
+```
+
+```json
+{
+  "turbo": {
+    "tasks": {
+      "build": {
+        "outputs": ["dist/**"],
+        "cache": true
+      },
+      "test": {
+        "outputs": [".coverage/**"]
+      },
+      "lint": {
+        "outputs": []
+      }
+    }
+  }
+}
+```
+
+## Monorepo Structure
+
+```
+monorepo/
+├── apps/
+│   ├── web/
+│   │   ├── src/
+│   │   └── package.json
+│   └── api/
+│       ├── src/
+│       └── package.json
+├── packages/
+│   ├── ui/
+│   │   ├── src/
+│   │   └── package.json
+│   ├── utils/
+│   │   ├── src/
+│   │   └── package.json
+│   └── config/
+│       └── package.json
+├── turbo.json
+└── package.json
+```
+
+## Workspace Dependencies
+
+```json
+{
+  "name": "web",
+  "dependencies": {
+    "@monorepo/ui": "workspace:*",
+    "@monorepo/utils": "workspace:*"
+  }
+}
+```
+
+## Shared Configuration
+
+```javascript
+// packages/config/eslint.js
+module.exports = {
+  extends: ['next/core-web-vitals'],
+  rules: {
+    'react/react-in-jsx-scope': 'off'
+  }
+};
+
+// apps/web/.eslintrc.js
+module.exports = {
+  extends: ['@monorepo/config/eslint']
+};
+```
+
+## Running Tasks
+
+```bash
+# Run task in all workspaces
+turbo run build
+
+# Run only in changed workspaces
+turbo run build --only-affected
+
+# Run with filter
+turbo run build --filter=@monorepo/ui
+
+# Run in parallel
+turbo run build test --parallel
+
+# Watch mode
+turbo run dev
+```
+
+## Pnpm Workspace
+
+```yaml
+# pnpm-workspace.yaml
+packages:
+  - 'apps/*'
+  - 'packages/*'
+```
+
+```bash
+# Install dependencies across workspaces
+pnpm install
+
+# Add dependency to specific workspace
+pnpm add react --filter @monorepo/ui
+
+# Run script in workspace
+pnpm --filter @monorepo/ui build
+```
+
+## CI/CD Integration
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+      
+      - name: Install dependencies
+        run: pnpm install
+      
+      - name: Build
+        run: turbo run build --filter=[HEAD~1]
+      
+      - name: Test
+        run: turbo run test
+      
+      - name: Lint
+        run: turbo run lint
+```
+
+## Best Practices
+
+✅ **Clear boundaries** - Each package has single purpose
+✅ **Shared dependencies** - Hoist common packages
+✅ **Version consistency** - Lock versions across workspaces
+✅ **Internal dependencies** - Reference via workspace protocol
+✅ **Documentation** - Document workspace structure
+
+## Resources
+
+- [Turborepo Documentation](https://turbo.build/repo/docs)
+- [pnpm Workspaces](https://pnpm.io/workspaces)
+- [Nx Monorepo](https://nx.dev/)

package/kit/.claude/skills/tooling-testing-frameworks.md

@@ -0,0 +1,207 @@
+# Testing Frameworks
+
+Overview of popular testing tools and frameworks.
+
+## Vitest (Fast Unit Testing)
+
+```typescript
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+describe('Math Utils', () => {
+  it('should add numbers', () => {
+    expect(add(2, 3)).toBe(5);
+  });
+
+  it('should handle negative numbers', () => {
+    expect(add(-2, 3)).toBe(1);
+  });
+});
+
+// Mocking
+vi.mock('./database');
+const mockDb = vi.hoisted(() => ({
+  query: vi.fn()
+}));
+
+describe('UserService', () => {
+  it('should fetch user from database', async () => {
+    mockDb.query.mockResolvedValueOnce({ id: '1', name: 'John' });
+    
+    const user = await getUserService().getUser('1');
+    
+    expect(user.name).toBe('John');
+    expect(mockDb.query).toHaveBeenCalledWith('SELECT * FROM users WHERE id = 1');
+  });
+});
+```
+
+## Jest (Industry Standard)
+
+```typescript
+import { jest } from '@jest/globals';
+
+describe('PaymentService', () => {
+  let paymentService: PaymentService;
+
+  beforeEach(() => {
+    paymentService = new PaymentService();
+  });
+
+  it('should process payment', async () => {
+    const result = await paymentService.process({
+      amount: 100,
+      currency: 'USD'
+    });
+
+    expect(result.status).toBe('success');
+    expect(result).toHaveProperty('transactionId');
+  });
+
+  it('should retry on failure', async () => {
+    const processSpy = jest.spyOn(paymentService, 'process');
+    processSpy.mockRejectedValueOnce(new Error('Network error'));
+
+    try {
+      await paymentService.process({ amount: 100 });
+    } catch (e) {
+      expect(processSpy).toHaveBeenCalled();
+    }
+  });
+});
+```
+
+## Testing Library (UI Testing)
+
+```typescript
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { Counter } from './Counter';
+
+describe('Counter Component', () => {
+  it('should increment count on button click', () => {
+    render(<Counter />);
+    
+    const button = screen.getByRole('button', { name: /increment/i });
+    fireEvent.click(button);
+    
+    expect(screen.getByText('Count: 1')).toBeInTheDocument();
+  });
+
+  it('should handle async operations', async () => {
+    render(<UserProfile userId="1" />);
+    
+    await waitFor(() => {
+      expect(screen.getByText('John Doe')).toBeInTheDocument();
+    });
+  });
+});
+```
+
+## Cypress (E2E Testing)
+
+```typescript
+describe('Login Flow', () => {
+  beforeEach(() => {
+    cy.visit('/login');
+  });
+
+  it('should login with valid credentials', () => {
+    cy.get('input[name="email"]').type('user@example.com');
+    cy.get('input[name="password"]').type('password123');
+    cy.get('button:contains("Sign In")').click();
+
+    cy.url().should('include', '/dashboard');
+    cy.get('h1:contains("Dashboard")').should('be.visible');
+  });
+
+  it('should show error with invalid credentials', () => {
+    cy.get('input[name="email"]').type('invalid@example.com');
+    cy.get('input[name="password"]').type('wrong');
+    cy.get('button:contains("Sign In")').click();
+
+    cy.get('[role="alert"]').should('contain', 'Invalid credentials');
+  });
+});
+```
+
+## NightwatchJS
+
+```typescript
+module.exports = {
+  'Login with valid credentials': (browser) => {
+    browser
+      .navigateTo('http://localhost:3000/login')
+      .setValue('input[name="email"]', 'user@example.com')
+      .setValue('input[name="password"]', 'password123')
+      .click('button[type="submit"]')
+      .waitForElementVisible('h1.dashboard-title')
+      .assert.urlEquals('http://localhost:3000/dashboard')
+      .end();
+  }
+};
+```
+
+## Mocha + Chai
+
+```typescript
+import { expect } from 'chai';
+import { greet } from './greeting';
+
+describe('Greeting', () => {
+  it('should return greeting message', () => {
+    const result = greet('John');
+    expect(result).to.equal('Hello, John!');
+  });
+
+  it('should handle empty name', () => {
+    const result = greet('');
+    expect(result).to.equal('Hello!');
+  });
+
+  it('should be a string', () => {
+    const result = greet('Jane');
+    expect(result).to.be.a('string');
+  });
+});
+```
+
+## Test Coverage
+
+```bash
+# Generate coverage report
+jest --coverage
+
+# Show coverage for specific file
+vitest --coverage src/utils.ts
+
+# Minimum coverage threshold
+# package.json
+{
+  "jest": {
+    "collectCoverageFrom": ["src/**/*.ts"],
+    "coveragePathIgnorePatterns": ["/node_modules/"],
+    "coverageThreshold": {
+      "global": {
+        "branches": 80,
+        "functions": 80,
+        "lines": 80,
+        "statements": 80
+      }
+    }
+  }
+}
+```
+
+## Best Practices
+
+✅ **Test behavior, not implementation** - Focus on outputs
+✅ **Meaningful test names** - Describe what is being tested
+✅ **DRY test code** - Extract common setup
+✅ **Fast tests** - Mock external dependencies
+✅ **Coverage** - Aim for 80%+ coverage
+
+## Resources
+
+- [Vitest](https://vitest.dev/)
+- [Jest](https://jestjs.io/)
+- [Testing Library](https://testing-library.com/)
+- [Cypress](https://www.cypress.io/)

package/kit/.claude/skills/tooling-typescript.md

@@ -0,0 +1,156 @@
+# TypeScript
+
+Typed superset of JavaScript with static type checking and excellent tooling.
+
+## Basic Types
+
+```typescript
+// Primitives
+const str: string = "hello";
+const num: number = 42;
+const bool: boolean = true;
+const nothing: null = null;
+const undefined_val: undefined = undefined;
+
+// Collections
+const arr: number[] = [1, 2, 3];
+const tuple: [string, number] = ["name", 42];
+const obj: { name: string; age: number } = { name: "John", age: 30 };
+
+// Functions
+const add = (a: number, b: number): number => a + b;
+const greet = (name: string): void => console.log(`Hello, ${name}`);
+const optional = (x?: number): number | undefined => x;
+```
+
+## Interfaces & Types
+
+```typescript
+// Interface (structural typing)
+interface User {
+  id: number;
+  name: string;
+  email?: string; // Optional
+  readonly created_at: Date; // Readonly
+}
+
+// Type (more flexible)
+type Admin = User & { admin_level: number };
+type Status = "active" | "inactive" | "pending";
+
+// Function type
+type Handler = (event: Event) => void;
+
+// Generics
+interface Container<T> {
+  value: T;
+  get(): T;
+  set(v: T): void;
+}
+```
+
+## Classes
+
+```typescript
+class Animal {
+  protected name: string;
+  private age: number = 0;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  protected getAge() {
+    return this.age;
+  }
+}
+
+class Dog extends Animal {
+  bark() {
+    console.log(`${this.name} barks!`);
+  }
+}
+```
+
+## Advanced Patterns
+
+### Utility Types
+```typescript
+// Partial - make all properties optional
+type PartialUser = Partial<User>;
+
+// Required - make all properties required
+type RequiredUser = Required<User>;
+
+// Pick - select specific properties
+type UserPreview = Pick<User, 'id' | 'name'>;
+
+// Omit - exclude properties
+type UserWithoutEmail = Omit<User, 'email'>;
+
+// Record - create object with specific keys
+type Status = 'active' | 'inactive';
+const statusCount: Record<Status, number> = {
+  active: 10,
+  inactive: 5,
+};
+```
+
+### Generics
+```typescript
+function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
+  return obj[key];
+}
+
+const user = { name: "John", age: 30 };
+const name = getProperty(user, 'name'); // string
+```
+
+### Discriminated Unions
+```typescript
+type Result<T> = 
+  | { status: 'success'; data: T }
+  | { status: 'error'; error: Error };
+
+function handle<T>(result: Result<T>) {
+  if (result.status === 'success') {
+    console.log(result.data); // T
+  } else {
+    console.log(result.error); // Error
+  }
+}
+```
+
+## Strict Mode Configuration
+
+```json
+{
+  "compilerOptions": {
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}
+```
+
+## Best Practices
+
+1. **Always use strict mode**: Catch more errors at compile time
+2. **Avoid any**: Use unknown or specific types instead
+3. **Use readonly**: For immutable data
+4. **Narrow types**: Use type guards and discriminated unions
+5. **Generic constraints**: Limit what types can be used
+
+## Resources
+
+- [TypeScript Handbook](https://www.typescriptlang.org/docs/)
+- [TypeScript Deep Dive](https://basarat.gitbook.io/typescript/)

package/kit/.claude/skills/ui-a11y.md

@@ -0,0 +1,106 @@
+# Accessibility (a11y)
+
+## Overview
+Build inclusive UIs that work for everyone — screen readers, keyboard users, and people with disabilities.
+
+## Semantic HTML
+
+```tsx
+// BAD — div soup
+<div onClick={handleClick}>Click me</div>
+<div class="nav"><div>Home</div><div>About</div></div>
+
+// GOOD — semantic elements
+<button onClick={handleClick} type="button">Click me</button>
+<nav aria-label="Main navigation">
+  <ul>
+    <li><a href="/">Home</a></li>
+    <li><a href="/about">About</a></li>
+  </ul>
+</nav>
+```
+
+## ARIA Roles and Labels
+
+```tsx
+// Modal
+<div role="dialog" aria-modal="true" aria-labelledby="modal-title" aria-describedby="modal-desc">
+  <h2 id="modal-title">Confirm Delete</h2>
+  <p id="modal-desc">This action cannot be undone.</p>
+  <button onClick={onClose} aria-label="Close dialog">✕</button>
+</div>
+
+// Loading state
+<button disabled aria-busy={isLoading} aria-label={isLoading ? 'Saving...' : 'Save'}>
+  {isLoading ? <Spinner /> : 'Save'}
+</button>
+
+// Form with error
+<div>
+  <label htmlFor="email">Email</label>
+  <input
+    id="email"
+    type="email"
+    aria-required="true"
+    aria-invalid={!!error}
+    aria-describedby={error ? 'email-error' : undefined}
+  />
+  {error && <p id="email-error" role="alert">{error}</p>}
+</div>
+```
+
+## Keyboard Navigation
+
+```tsx
+// Trap focus in modal
+import { useEffect, useRef } from 'react';
+
+function Modal({ onClose }: { onClose: () => void }) {
+  const ref = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const focusable = el.querySelectorAll<HTMLElement>('button, [href], input, [tabindex]:not([tabindex="-1"])');
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+
+    first?.focus();
+
+    function handleTab(e: KeyboardEvent) {
+      if (e.key !== 'Tab') return;
+      if (e.shiftKey ? document.activeElement === first : document.activeElement === last) {
+        e.preventDefault();
+        (e.shiftKey ? last : first)?.focus();
+      }
+    }
+
+    el.addEventListener('keydown', handleTab);
+    return () => el.removeEventListener('keydown', handleTab);
+  }, []);
+
+  return <div ref={ref} role="dialog">{/* ... */}</div>;
+}
+```
+
+## Color Contrast Check
+
+```typescript
+// Ensure 4.5:1 ratio for normal text, 3:1 for large text
+// WCAG AA compliance
+const colors = {
+  textOnWhite: '#374151',   // 10.7:1 ✓
+  primaryOnWhite: '#1d4ed8', // 6.8:1 ✓
+  errorText: '#dc2626',      // 4.5:1 ✓
+};
+```
+
+## Best Practices
+- Test with keyboard only (Tab, Enter, Escape, Arrow keys)
+- Test with VoiceOver (macOS) or NVDA (Windows)
+- Run `npx axe-cli http://localhost:3000` for automated checks
+- Add `aria-live="polite"` to dynamic content areas
+
+## Resources
+- [WCAG 2.1 guidelines](https://www.w3.org/TR/WCAG21/)
+- [axe DevTools](https://www.deque.com/axe/)