claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/testing-snapshot.md

@@ -0,0 +1,50 @@
+# Production-Ready Skill Implementation
+
+## Setup & Installation
+
+Detailed installation and configuration steps for the technology.
+
+## Core Concepts
+
+Fundamental patterns and approaches.
+
+## Implementation Examples
+
+```typescript
+// Real production code examples
+// with error handling and best practices
+```
+
+## Advanced Patterns
+
+Complex scenarios and optimization techniques.
+
+## Performance Optimization
+
+Tips for maximizing efficiency and speed.
+
+## Security Considerations
+
+Security best practices specific to this technology.
+
+## Testing
+
+How to properly test this feature.
+
+## Monitoring & Debugging
+
+Tools and techniques for production support.
+
+## Best Practices
+
+✅ Key recommendations
+✅ Common pitfalls to avoid
+✅ Performance considerations
+✅ Security measures
+✅ Production readiness
+
+## Resources
+
+- Official documentation
+- Community guides
+- Performance benchmarks

package/kit/.claude/skills/testing-vitest.md

@@ -0,0 +1,172 @@
+# Vitest
+
+Lightning-fast unit test framework.
+
+## Setup
+
+```bash
+npm install -D vitest @vitest/ui
+npm install -D @testing-library/react @testing-library/dom
+```
+
+## Configuration
+
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: ['node_modules/', 'src/test/']
+    }
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src')
+    }
+  }
+});
+```
+
+## Basic Tests
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+
+describe('Math Utils', () => {
+  it('should add numbers correctly', () => {
+    expect(2 + 2).toBe(4);
+  });
+
+  it('should handle negative numbers', () => {
+    expect(-5 + 3).toBe(-2);
+  });
+
+  it('should match objects', () => {
+    const user = { name: 'John', age: 30 };
+    expect(user).toEqual({ name: 'John', age: 30 });
+  });
+
+  it('should test arrays', () => {
+    const numbers = [1, 2, 3];
+    expect(numbers).toContain(2);
+    expect(numbers.length).toBe(3);
+  });
+});
+```
+
+## Async Testing
+
+```typescript
+describe('Async Operations', () => {
+  it('should fetch data', async () => {
+    const data = await fetchUser(1);
+    expect(data.id).toBe(1);
+  });
+
+  it('should handle promise', () => {
+    return expect(Promise.resolve(42)).resolves.toBe(42);
+  });
+
+  it('should handle rejection', () => {
+    return expect(Promise.reject('error')).rejects.toBe('error');
+  });
+});
+```
+
+## Mocking
+
+```typescript
+import { describe, it, expect, vi } from 'vitest';
+
+describe('Database Operations', () => {
+  it('should call database', async () => {
+    const mockDB = vi.fn(() => ({ id: 1, name: 'John' }));
+
+    const result = mockDB();
+
+    expect(mockDB).toHaveBeenCalled();
+    expect(result).toEqual({ id: 1, name: 'John' });
+  });
+
+  it('should mock modules', () => {
+    vi.mock('./api', () => ({
+      getUser: vi.fn(() => ({ id: 1 }))
+    }));
+
+    const { getUser } = require('./api');
+    expect(getUser()).toEqual({ id: 1 });
+  });
+
+  it('should spy on methods', () => {
+    const obj = {
+      method: () => 'original'
+    };
+
+    const spy = vi.spyOn(obj, 'method');
+    obj.method();
+
+    expect(spy).toHaveBeenCalled();
+    expect(spy).toHaveReturnedWith('original');
+  });
+});
+```
+
+## React Component Testing
+
+```typescript
+import { render, screen, fireEvent } from '@testing-library/react';
+import { Button } from './Button';
+
+describe('Button Component', () => {
+  it('renders button with text', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByText('Click me')).toBeInTheDocument();
+  });
+
+  it('handles click events', () => {
+    const handleClick = vi.fn();
+    render(<Button onClick={handleClick}>Click</Button>);
+
+    fireEvent.click(screen.getByText('Click'));
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables button when loading', () => {
+    render(<Button disabled>Loading...</Button>);
+    expect(screen.getByRole('button')).toBeDisabled();
+  });
+});
+```
+
+## Coverage
+
+```bash
+# Run with coverage
+vitest --coverage
+
+# Open coverage report
+open coverage/index.html
+```
+
+## Best Practices
+
+✅ **Test behavior** - Not implementation
+✅ **Clear names** - Describe what is tested
+✅ **DRY setup** - Use beforeEach for common setup
+✅ **Isolated tests** - No dependencies between tests
+✅ **Good coverage** - Aim for 80%+ coverage
+
+## Resources
+
+- [Vitest Documentation](https://vitest.dev/)
+- [Testing Library](https://testing-library.com/)

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

@@ -0,0 +1,91 @@
+# Biome (Linter + Formatter)
+
+## Overview
+Biome is a fast, all-in-one linter and formatter for JavaScript/TypeScript — replaces ESLint + Prettier in one tool.
+
+## Setup
+
+```bash
+npm install -D @biomejs/biome
+npx @biomejs/biome init
+```
+
+## biome.json Configuration
+
+```json
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "organizeImports": { "enabled": true },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "a11y": { "recommended": true },
+      "security": { "recommended": true },
+      "performance": { "noDelete": "warn" },
+      "correctness": { "noUnusedVariables": "error" }
+    }
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "trailingCommas": "es5",
+      "semicolons": "always"
+    }
+  },
+  "files": {
+    "ignore": ["node_modules", "dist", ".next", "coverage"]
+  }
+}
+```
+
+## Scripts
+
+```json
+// package.json
+{
+  "scripts": {
+    "lint": "biome lint .",
+    "lint:fix": "biome lint --apply .",
+    "format": "biome format --write .",
+    "check": "biome check .",
+    "check:fix": "biome check --apply ."
+  }
+}
+```
+
+## VS Code Integration
+
+```json
+// .vscode/settings.json
+{
+  "editor.defaultFormatter": "biomejs.biome",
+  "editor.formatOnSave": true,
+  "[javascript]": { "editor.defaultFormatter": "biomejs.biome" },
+  "[typescript]": { "editor.defaultFormatter": "biomejs.biome" },
+  "[typescriptreact]": { "editor.defaultFormatter": "biomejs.biome" }
+}
+```
+
+## CI/CD Integration
+
+```yaml
+# .github/workflows/ci.yml
+- name: Lint and Format check
+  run: npx @biomejs/biome ci .
+```
+
+## Best Practices
+- Use `biome check --apply` in pre-commit hooks for auto-fix
+- Biome is 20-100x faster than ESLint + Prettier
+- Migrate gradually with `biome migrate eslint --include-inspired`
+- Set `"linter.rules.recommended": true` as base
+
+## Resources
+- [Biome docs](https://biomejs.dev/guides/getting-started/)

package/kit/.claude/skills/tooling-build-tools.md

@@ -0,0 +1,166 @@
+# Build Tools
+
+Compilation, bundling, and asset optimization.
+
+## Vite
+
+```typescript
+// vite.config.ts
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src')
+    }
+  },
+  build: {
+    target: 'esnext',
+    minify: 'terser',
+    sourcemap: false,
+    rollupOptions: {
+      output: {
+        manualChunks: {
+          'vendor': ['react', 'react-dom']
+        }
+      }
+    }
+  },
+  server: {
+    port: 3000,
+    proxy: {
+      '/api': 'http://localhost:5000'
+    }
+  }
+});
+```
+
+## Webpack Configuration
+
+```javascript
+// webpack.config.js
+const path = require('path');
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+
+module.exports = {
+  mode: 'production',
+  entry: './src/index.ts',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: '[name].[contenthash].js'
+  },
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: 'ts-loader',
+        exclude: /node_modules/
+      },
+      {
+        test: /\.css$/,
+        use: ['style-loader', 'css-loader']
+      }
+    ]
+  },
+  plugins: [
+    new HtmlWebpackPlugin({
+      template: './src/index.html'
+    })
+  ],
+  optimization: {
+    splitChunks: {
+      chunks: 'all'
+    }
+  }
+};
+```
+
+## ESBuild
+
+```typescript
+import esbuild from 'esbuild';
+
+await esbuild.build({
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  outfile: 'dist/bundle.js',
+  minify: true,
+  sourcemap: true,
+  target: 'esnext',
+  loader: {
+    '.png': 'dataurl'
+  }
+});
+```
+
+## Bun Runtime
+
+```bash
+# Install
+curl -fsSL https://bun.sh/install | bash
+
+# Run TypeScript directly
+bun run src/index.ts
+
+# Bundle
+bun build ./src/index.ts --outdir ./dist
+```
+
+## Rollup
+
+```javascript
+// rollup.config.js
+import resolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import typescript from '@rollup/plugin-typescript';
+
+export default {
+  input: 'src/index.ts',
+  output: {
+    file: 'dist/bundle.js',
+    format: 'cjs'
+  },
+  plugins: [
+    typescript(),
+    resolve(),
+    commonjs()
+  ],
+  external: ['react']
+};
+```
+
+## SWC (Rust Compiler)
+
+```json
+{
+  ".swcrc": {
+    "jsc": {
+      "parser": {
+        "syntax": "typescript"
+      },
+      "target": "es2020",
+      "minify": {
+        "compress": true
+      }
+    }
+  }
+}
+```
+
+## Best Practices
+
+✅ **Code splitting** - Chunk dependencies
+✅ **Lazy loading** - Load routes/features on demand
+✅ **Tree shaking** - Remove unused code
+✅ **Caching** - Use content hashes
+✅ **Source maps** - Debug production code
+
+## Resources
+
+- [Vite Documentation](https://vitejs.dev/)
+- [Webpack Guide](https://webpack.js.org/guides/)
+- [ESBuild](https://esbuild.github.io/)
+- [Bun Runtime](https://bun.sh/)

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

@@ -0,0 +1,94 @@
+# Bun Runtime
+
+## Overview
+Bun is a fast JavaScript runtime, package manager, bundler, and test runner in one tool.
+
+## Installation
+
+```bash
+curl -fsSL https://bun.sh/install | bash
+```
+
+## Package Management
+
+```bash
+bun install                    # Install all deps (fast!)
+bun add react react-dom        # Add packages
+bun add -D typescript          # Add dev deps
+bun remove lodash              # Remove
+bun update                     # Update all
+```
+
+## Run Scripts
+
+```bash
+bun run dev                    # Run script from package.json
+bun run src/index.ts           # Run TypeScript file directly
+bun --hot src/server.ts        # Hot reload (like nodemon)
+```
+
+## HTTP Server
+
+```typescript
+// server.ts
+Bun.serve({
+  port: 3000,
+  async fetch(req: Request) {
+    const url = new URL(req.url);
+
+    if (url.pathname === '/api/users') {
+      const users = await db.user.findMany();
+      return Response.json(users);
+    }
+
+    if (url.pathname === '/health') {
+      return Response.json({ status: 'ok' });
+    }
+
+    return new Response('Not Found', { status: 404 });
+  },
+});
+```
+
+## SQLite with Bun
+
+```typescript
+import { Database } from 'bun:sqlite';
+
+const db = new Database('myapp.db');
+db.run(`CREATE TABLE IF NOT EXISTS users (id TEXT PRIMARY KEY, name TEXT, email TEXT)`);
+
+const insert = db.prepare('INSERT INTO users VALUES ($id, $name, $email)');
+insert.run({ $id: crypto.randomUUID(), $name: 'Alice', $email: 'alice@example.com' });
+
+const users = db.prepare('SELECT * FROM users').all();
+```
+
+## Testing
+
+```typescript
+// users.test.ts
+import { describe, expect, it } from 'bun:test';
+
+describe('User service', () => {
+  it('creates a user', async () => {
+    const user = await createUser({ email: 'test@example.com', name: 'Test' });
+    expect(user.id).toBeDefined();
+    expect(user.email).toBe('test@example.com');
+  });
+});
+```
+
+```bash
+bun test             # Run all tests
+bun test --watch     # Watch mode
+bun test --coverage  # With coverage
+```
+
+## Best Practices
+- Use `bun:sqlite` for local dev databases — no setup needed
+- Use `--hot` flag instead of `nodemon` for server development
+- `bun build` for bundling: `bun build ./src/index.ts --outdir ./dist --target node`
+
+## Resources
+- [Bun docs](https://bun.sh/docs)

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

@@ -0,0 +1,103 @@
+# ESLint
+
+## Overview
+ESLint statically analyzes JavaScript/TypeScript code to find bugs and enforce code style.
+
+## Setup (ESLint v9 flat config)
+
+```bash
+npm install -D eslint @eslint/js typescript-eslint eslint-plugin-react-hooks
+```
+
+## eslint.config.js (Flat Config)
+
+```typescript
+// eslint.config.js
+import js from '@eslint/js';
+import tsPlugin from 'typescript-eslint';
+import reactHooks from 'eslint-plugin-react-hooks';
+
+export default tsPlugin.config(
+  js.configs.recommended,
+  ...tsPlugin.configs.recommended,
+  {
+    plugins: { 'react-hooks': reactHooks },
+    rules: {
+      ...reactHooks.configs.recommended.rules,
+      '@typescript-eslint/no-explicit-any': 'error',
+      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'no-console': ['warn', { allow: ['warn', 'error'] }],
+      'prefer-const': 'error',
+    },
+  },
+  {
+    ignores: ['dist/**', '.next/**', 'coverage/**', '*.config.js'],
+  }
+);
+```
+
+## Scripts
+
+```json
+{
+  "scripts": {
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  }
+}
+```
+
+## Next.js ESLint Config
+
+```bash
+npm install -D eslint-config-next
+```
+
+```javascript
+// eslint.config.js (Next.js)
+import { FlatCompat } from '@eslint/eslintrc';
+const compat = new FlatCompat();
+
+export default [
+  ...compat.extends('next/core-web-vitals', 'next/typescript'),
+  { rules: { '@typescript-eslint/no-explicit-any': 'error' } }
+];
+```
+
+## Pre-commit Hook with lint-staged
+
+```bash
+npm install -D husky lint-staged
+npx husky init
+```
+
+```json
+// package.json
+{
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx}": ["eslint --fix", "prettier --write"]
+  }
+}
+```
+
+```bash
+echo "npx lint-staged" > .husky/pre-commit
+```
+
+## Custom Rule Example
+
+```typescript
+// Only allow logger, not console.log
+module.exports = {
+  rules: {
+    'no-restricted-syntax': ['error', {
+      selector: "CallExpression[callee.object.name='console'][callee.property.name='log']",
+      message: 'Use logger.info() instead of console.log()'
+    }]
+  }
+};
+```
+
+## Resources
+- [ESLint docs](https://eslint.org/docs/latest/)
+- [typescript-eslint](https://typescript-eslint.io)