claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/monitoring-error-tracking.md

@@ -0,0 +1,217 @@
+# Error Tracking & Reporting
+
+Catch and track errors in production applications.
+
+## Sentry Integration
+
+```typescript
+import * as Sentry from "@sentry/node";
+import { NodeProfilingIntegration } from "@sentry/profiling-node";
+
+Sentry.init({
+  dsn: process.env.SENTRY_DSN,
+  integrations: [
+    new Sentry.Integrations.Http({ tracing: true }),
+    new NodeProfilingIntegration()
+  ],
+  tracesSampleRate: 1.0,
+  profilesSampleRate: 1.0
+});
+
+// Express middleware
+app.use(Sentry.Handlers.requestHandler());
+
+// Your routes...
+
+app.use(Sentry.Handlers.errorHandler());
+
+// Manual error reporting
+try {
+  await someAsyncOperation();
+} catch (error) {
+  Sentry.captureException(error, {
+    tags: {
+      section: 'critical'
+    },
+    extra: {
+      userId: req.user.id,
+      orderId: req.body.orderId
+    }
+  });
+}
+```
+
+## Rollbar Integration
+
+```typescript
+import Rollbar from 'rollbar';
+
+const rollbar = new Rollbar({
+  accessToken: process.env.ROLLBAR_ACCESS_TOKEN,
+  environment: process.env.NODE_ENV
+});
+
+app.use((err: any, req: any, res: any, next: any) => {
+  rollbar.error(err, { request: req });
+  res.status(500).json({ error: 'Internal Server Error' });
+});
+
+// Manual logging
+rollbar.info('User login', { userId: user.id });
+```
+
+## Custom Error Tracking
+
+```typescript
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+interface ErrorLog {
+  timestamp: Date;
+  message: string;
+  stack?: string;
+  context?: Record<string, any>;
+  severity: 'error' | 'warning' | 'info';
+}
+
+class ErrorTracker {
+  private logDir = './logs';
+
+  async logError(error: Error, context?: any) {
+    const log: ErrorLog = {
+      timestamp: new Date(),
+      message: error.message,
+      stack: error.stack,
+      context,
+      severity: 'error'
+    };
+
+    // Write to file
+    const filename = `${new Date().toISOString().split('T')[0]}.json`;
+    const filepath = path.join(this.logDir, filename);
+
+    const existing = await this.readLogs(filepath);
+    existing.push(log);
+
+    await fs.writeFile(filepath, JSON.stringify(existing, null, 2));
+
+    // Alert if critical
+    if (context?.critical) {
+      await this.alertAdmins(log);
+    }
+  }
+
+  private async readLogs(filepath: string): Promise<ErrorLog[]> {
+    try {
+      const content = await fs.readFile(filepath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return [];
+    }
+  }
+
+  private async alertAdmins(log: ErrorLog) {
+    // Send alert via Slack, email, etc.
+    console.error('CRITICAL ERROR:', log.message);
+  }
+}
+
+const errorTracker = new ErrorTracker();
+
+app.use((err: any, req: any, res: any, next: any) => {
+  errorTracker.logError(err, {
+    url: req.url,
+    method: req.method,
+    userId: req.user?.id,
+    critical: err.statusCode >= 500
+  });
+
+  res.status(500).json({ error: 'Internal Server Error' });
+});
+```
+
+## Source Maps
+
+```typescript
+// webpack.config.js
+module.exports = {
+  mode: 'production',
+  devtool: 'hidden-source-map',
+  // ...
+};
+
+// Upload source maps to Sentry
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function uploadSourceMaps() {
+  const version = process.env.RELEASE || 'dev';
+
+  await execAsync(`
+    sentry-cli releases files upload-sourcemaps \
+      --org myorg \
+      --project myproject \
+      --release ${version} \
+      ./dist
+  `);
+}
+```
+
+## Error Boundaries (React)
+
+```typescript
+import React, { ReactNode } from 'react';
+import * as Sentry from "@sentry/react";
+
+interface Props {
+  children: ReactNode;
+}
+
+interface State {
+  hasError: boolean;
+  error?: Error;
+}
+
+class ErrorBoundary extends React.Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+
+  static getDerivedStateFromError(error: Error) {
+    return { hasError: true, error };
+  }
+
+  componentDidCatch(error: Error, errorInfo: any) {
+    Sentry.captureException(error, { contexts: { react: errorInfo } });
+  }
+
+  render() {
+    if (this.state.hasError) {
+      return <h1>Something went wrong</h1>;
+    }
+
+    return this.props.children;
+  }
+}
+
+export default Sentry.withErrorBoundary(ErrorBoundary, {
+  fallback: <h1>An error occurred</h1>
+});
+```
+
+## Best Practices
+
+✅ **Capture context** - Include user, request, state info
+✅ **Alert on critical** - Real-time notifications for severe errors
+✅ **Source maps** - Map minified code to original
+✅ **Group errors** - Identify duplicate issues
+✅ **Monitor trends** - Track error rates over time
+
+## Resources
+
+- [Sentry Documentation](https://docs.sentry.io/)
+- [Rollbar](https://rollbar.com/)
+- [Bugsnag](https://www.bugsnag.com/)

package/kit/.claude/skills/nodejs-streams.md

@@ -0,0 +1,168 @@
+# Node.js Streams
+
+Efficient data processing with streams.
+
+## Stream Types
+
+```typescript
+import { Readable, Writable, Transform, Duplex } from 'stream';
+
+// Readable stream
+const readable = new Readable({
+  read() {
+    this.push('data');
+    this.push(null); // Signal end
+  }
+});
+
+// Writable stream
+const writable = new Writable({
+  write(chunk, encoding, callback) {
+    console.log('Received:', chunk);
+    callback();
+  }
+});
+
+// Transform stream
+const transform = new Transform({
+  transform(chunk, encoding, callback) {
+    const transformed = chunk.toString().toUpperCase();
+    this.push(transformed);
+    callback();
+  }
+});
+
+// Duplex (both readable and writable)
+const duplex = new Duplex({
+  read() {},
+  write(chunk, encoding, callback) {
+    console.log('Written:', chunk);
+    callback();
+  }
+});
+```
+
+## Piping
+
+```typescript
+import fs from 'fs';
+import zlib from 'zlib';
+
+// Simple pipe
+fs.createReadStream('input.txt')
+  .pipe(fs.createWriteStream('output.txt'));
+
+// Multiple transforms
+fs.createReadStream('large-file.txt')
+  .pipe(transform1)
+  .pipe(transform2)
+  .pipe(fs.createWriteStream('output.txt'));
+
+// Compression
+fs.createReadStream('file.txt')
+  .pipe(zlib.createGzip())
+  .pipe(fs.createWriteStream('file.txt.gz'));
+
+// Handle errors
+fs.createReadStream('input.txt')
+  .on('error', (error) => console.error('Read error:', error))
+  .pipe(fs.createWriteStream('output.txt'))
+  .on('error', (error) => console.error('Write error:', error));
+```
+
+## Processing Large Files
+
+```typescript
+function processLargeCSV(filePath: string) {
+  const { createReadStream } = require('fs');
+  const { createInterface } = require('readline');
+
+  const stream = createReadStream(filePath);
+  const rl = createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+
+  let lineCount = 0;
+
+  rl.on('line', (line) => {
+    lineCount++;
+    const record = JSON.parse(line);
+
+    // Process record
+    processRecord(record);
+
+    // Report progress every 1000 lines
+    if (lineCount % 1000 === 0) {
+      console.log(`Processed ${lineCount} lines`);
+    }
+  });
+
+  rl.on('close', () => {
+    console.log(`Total lines: ${lineCount}`);
+  });
+}
+```
+
+## Custom Transform
+
+```typescript
+const { Transform } = require('stream');
+
+class UpperCaseTransform extends Transform {
+  transform(chunk: any, encoding: string, callback: Function) {
+    const transformed = chunk.toString().toUpperCase();
+    this.push(transformed);
+    callback();
+  }
+}
+
+// Usage
+readable
+  .pipe(new UpperCaseTransform())
+  .pipe(writable);
+```
+
+## Memory Efficient Processing
+
+```typescript
+// Bad: Load entire file into memory
+const data = fs.readFileSync('large-file.txt', 'utf-8');
+const lines = data.split('\n');
+lines.forEach(processLine);
+
+// Good: Stream processing
+fs.createReadStream('large-file.txt')
+  .pipe(split())
+  .on('data', processLine);
+
+// Bad: Buffer accumulation
+let buffer = '';
+stream.on('data', (chunk) => {
+  buffer += chunk; // Can cause memory issues
+});
+
+// Good: Backpressure handling
+stream.on('data', (chunk) => {
+  if (!destination.write(chunk)) {
+    stream.pause();
+  }
+});
+
+destination.on('drain', () => {
+  stream.resume();
+});
+```
+
+## Best Practices
+
+✅ **Handle backpressure** - Pause when buffer full
+✅ **Error handling** - Listen for error events
+✅ **Piping** - Use pipe over manual event handlers
+✅ **Memory limits** - Monitor heap usage
+✅ **Cleanup** - Close streams properly
+
+## Resources
+
+- [Node.js Stream API](https://nodejs.org/api/stream.html)
+- [Stream Handbook](https://github.com/substack/stream-handbook)

package/kit/.claude/skills/oauth-integration.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/patterns-dependency-injection.md

@@ -0,0 +1,218 @@
+# Dependency Injection Patterns
+
+Managing dependencies and composing complex objects.
+
+## Constructor Injection
+
+```typescript
+// Define interfaces
+interface Database {
+  query(sql: string): Promise<any>;
+}
+
+interface Logger {
+  log(message: string): void;
+  error(message: string): void;
+}
+
+// Service with injected dependencies
+class UserService {
+  constructor(
+    private db: Database,
+    private logger: Logger
+  ) {}
+
+  async getUser(id: string) {
+    this.logger.log(`Fetching user ${id}`);
+    const user = await this.db.query(`SELECT * FROM users WHERE id = ${id}`);
+    return user;
+  }
+}
+
+// Concrete implementations
+class PostgresDatabase implements Database {
+  async query(sql: string) {
+    // PostgreSQL logic
+  }
+}
+
+class ConsoleLogger implements Logger {
+  log(message: string) {
+    console.log(`[LOG] ${message}`);
+  }
+  error(message: string) {
+    console.error(`[ERROR] ${message}`);
+  }
+}
+
+// Usage
+const db = new PostgresDatabase();
+const logger = new ConsoleLogger();
+const userService = new UserService(db, logger);
+```
+
+## Service Container
+
+```typescript
+class Container {
+  private services = new Map<string, any>();
+  private singletons = new Map<string, any>();
+
+  register(name: string, factory: () => any) {
+    this.services.set(name, factory);
+  }
+
+  singleton(name: string, factory: () => any) {
+    const instance = factory();
+    this.singletons.set(name, instance);
+  }
+
+  get(name: string): any {
+    // Return singleton if exists
+    if (this.singletons.has(name)) {
+      return this.singletons.get(name);
+    }
+
+    // Create instance from factory
+    const factory = this.services.get(name);
+    if (!factory) {
+      throw new Error(`Service ${name} not registered`);
+    }
+
+    return factory();
+  }
+}
+
+// Setup
+const container = new Container();
+
+container.singleton('db', () => new PostgresDatabase());
+container.singleton('logger', () => new ConsoleLogger());
+
+container.register('userService', () =>
+  new UserService(container.get('db'), container.get('logger'))
+);
+
+container.register('postService', () =>
+  new PostService(container.get('db'), container.get('logger'))
+);
+
+// Usage
+const userService = container.get('userService');
+```
+
+## Factory Pattern
+
+```typescript
+interface PaymentProvider {
+  charge(amount: number): Promise<void>;
+}
+
+class StripeProvider implements PaymentProvider {
+  async charge(amount: number) {
+    // Stripe implementation
+  }
+}
+
+class PayPalProvider implements PaymentProvider {
+  async charge(amount: number) {
+    // PayPal implementation
+  }
+}
+
+class PaymentProviderFactory {
+  static create(provider: 'stripe' | 'paypal'): PaymentProvider {
+    switch (provider) {
+      case 'stripe':
+        return new StripeProvider();
+      case 'paypal':
+        return new PayPalProvider();
+      default:
+        throw new Error(`Unknown provider: ${provider}`);
+    }
+  }
+}
+
+// Usage
+const provider = PaymentProviderFactory.create('stripe');
+await provider.charge(100);
+```
+
+## Async DI
+
+```typescript
+class Container {
+  private services = new Map<string, () => Promise<any>>();
+
+  async get(name: string): Promise<any> {
+    const factory = this.services.get(name);
+    if (!factory) {
+      throw new Error(`Service ${name} not found`);
+    }
+
+    return factory();
+  }
+
+  register(name: string, factory: () => Promise<any>) {
+    this.services.set(name, factory);
+  }
+}
+
+const container = new Container();
+
+container.register('db', async () => {
+  const db = new Database();
+  await db.connect();
+  return db;
+});
+
+// Usage
+const db = await container.get('db');
+```
+
+## Decorators
+
+```typescript
+import 'reflect-metadata';
+import { Inject } from 'tsyringe';
+import { Container } from 'tsyringe';
+
+@injectable()
+class Logger {
+  log(msg: string) {
+    console.log(msg);
+  }
+}
+
+@injectable()
+class UserService {
+  constructor(@Inject('logger') private logger: Logger) {}
+
+  getUser(id: string) {
+    this.logger.log(`Getting user ${id}`);
+  }
+}
+
+// Setup
+const container = new Container();
+container.registerSingleton('logger', Logger);
+container.register('userService', UserService);
+
+// Usage
+const userService = container.resolve(UserService);
+userService.getUser('123');
+```
+
+## Best Practices
+
+✅ **Program to interfaces** - Not implementations
+✅ **Single responsibility** - Each service has one job
+✅ **Dependency inversion** - Depend on abstractions
+✅ **Use containers** - For complex applications
+✅ **Testing** - Mock dependencies easily
+
+## Resources
+
+- [Dependency Injection](https://martinfowler.com/articles/injection.html)
+- [tsyringe](https://github.com/Microsoft/tsyringe)
+- [InversifyJS](https://inversify.io/)