claudeinone-cli 1.0.2 → 1.0.3

package/kit/.claude/skills/backend-hono.md

@@ -0,0 +1,95 @@
+# Hono
+
+Lightweight, ultra-fast web framework for edge runtimes (Cloudflare Workers, Deno, Node.js).
+
+## Hello World
+
+```typescript
+import { Hono } from 'hono';
+
+const app = new Hono();
+
+app.get('/', (c) => c.text('Hello, World!'));
+
+app.post('/users', async (c) => {
+  const body = await c.req.json();
+  return c.json({ created: body }, 201);
+});
+
+export default app;
+```
+
+## Routing
+
+```typescript
+const app = new Hono();
+
+app.get('/users', async (c) => {
+  return c.json(await db.users.list());
+});
+
+app.get('/users/:id', async (c) => {
+  const id = c.req.param('id');
+  const user = await db.users.get(id);
+  return c.json(user);
+});
+
+app.post('/users', async (c) => {
+  const body = await c.req.json();
+  const user = await db.users.create(body);
+  return c.json(user, 201);
+});
+```
+
+## Middleware
+
+```typescript
+// Built-in middleware
+app.use(cors());
+app.use(logger());
+
+// Custom middleware
+app.use(async (c, next) => {
+  const start = Date.now();
+  await next();
+  console.log(`${Date.now() - start}ms`);
+});
+
+// Route-specific middleware
+app.post('/api/*', authenticate, (c) => {
+  return c.json({ user: c.get('user') });
+});
+```
+
+## Parameters & Validation
+
+```typescript
+app.post('/items/:id', (c) => {
+  const id = c.req.param('id');
+  const query = c.req.query('page');
+  const body = c.req.json();
+  
+  return c.json({ id, query, body });
+});
+```
+
+## Edge Runtime Support
+
+```typescript
+// Works on Cloudflare Workers, Deno, Node.js
+// No environment-specific code needed
+export default app;
+```
+
+## Best Practices
+
+1. Leverage edge runtime when possible
+2. Keep middleware focused
+3. Use proper status codes
+4. Return structured responses
+5. Handle errors consistently
+
+## Resources
+
+- [Hono Documentation](https://hono.dev/)
+- [Edge Runtime Compatibility](https://hono.dev/docs/getting-started/cf-workers)

package/kit/.claude/skills/backend-java-spring.md

@@ -0,0 +1,198 @@
+# Spring Boot
+
+Java framework for building production-grade applications with dependency injection and autoconfiguration.
+
+## Basic Setup
+
+```java
+package com.example.api;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class Application {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}
+```
+
+## Controllers & Routing
+
+```java
+import org.springframework.web.bind.annotation.*;
+import org.springframework.http.HttpStatus;
+
+@RestController
+@RequestMapping("/api/users")
+public class UserController {
+    
+    @GetMapping("/{id}")
+    public UserDTO getUser(@PathVariable Long id) {
+        return userService.findById(id);
+    }
+    
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public UserDTO createUser(@RequestBody CreateUserRequest request) {
+        return userService.create(request);
+    }
+    
+    @PutMapping("/{id}")
+    public UserDTO updateUser(@PathVariable Long id, @RequestBody UpdateUserRequest request) {
+        return userService.update(id, request);
+    }
+    
+    @DeleteMapping("/{id}")
+    @ResponseStatus(HttpStatus.NO_CONTENT)
+    public void deleteUser(@PathVariable Long id) {
+        userService.delete(id);
+    }
+}
+```
+
+## Data & JPA
+
+```java
+import javax.persistence.*;
+
+@Entity
+@Table(name = "users")
+public class User {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+    
+    @Column(nullable = false)
+    private String name;
+    
+    @Column(unique = true, nullable = false)
+    private String email;
+    
+    @Temporal(TemporalType.TIMESTAMP)
+    @CreationTimestamp
+    private LocalDateTime createdAt;
+}
+
+// Repository
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+    List<User> findByNameContainingIgnoreCase(String name);
+}
+
+// Service
+@Service
+public class UserService {
+    private final UserRepository repository;
+    
+    public UserDTO findById(Long id) {
+        return repository.findById(id)
+            .map(this::toDTO)
+            .orElseThrow(() -> new NotFoundException("User not found"));
+    }
+    
+    @Transactional
+    public UserDTO create(CreateUserRequest request) {
+        User user = new User();
+        user.setName(request.getName());
+        user.setEmail(request.getEmail());
+        return toDTO(repository.save(user));
+    }
+}
+```
+
+## Dependency Injection
+
+```java
+@Component
+public class MyService {
+    private final UserRepository userRepository;
+    private final EmailService emailService;
+    
+    // Constructor injection (preferred)
+    public MyService(UserRepository userRepository, EmailService emailService) {
+        this.userRepository = userRepository;
+        this.emailService = emailService;
+    }
+}
+```
+
+## Exception Handling
+
+```java
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+    
+    @ExceptionHandler(NotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNotFound(NotFoundException e) {
+        return ResponseEntity
+            .status(HttpStatus.NOT_FOUND)
+            .body(new ErrorResponse("NOT_FOUND", e.getMessage()));
+    }
+    
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorResponse> handleGlobal(Exception e) {
+        return ResponseEntity
+            .status(HttpStatus.INTERNAL_SERVER_ERROR)
+            .body(new ErrorResponse("SERVER_ERROR", "Internal server error"));
+    }
+}
+```
+
+## Testing
+
+```java
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.web.servlet.MockMvc;
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class UserControllerTests {
+    
+    @Autowired
+    private MockMvc mockMvc;
+    
+    @Test
+    void testGetUser() throws Exception {
+        mockMvc.perform(get("/api/users/1"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.name").value("John"));
+    }
+}
+```
+
+## Configuration
+
+```yaml
+# application.yml
+spring:
+  datasource:
+    url: jdbc:postgresql://localhost:5432/mydb
+    username: user
+    password: pass
+  jpa:
+    hibernate:
+      ddl-auto: validate
+  server:
+    port: 8080
+```
+
+## Best Practices
+
+1. **Use constructor injection**
+2. **Keep controllers thin**
+3. **Use services for business logic**
+4. **Implement proper error handling**
+5. **Write comprehensive tests**
+6. **Use transactions for data consistency**
+7. **Monitor application metrics**
+
+## Resources
+
+- [Spring Boot Docs](https://spring.io/projects/spring-boot)
+- [Spring Data JPA](https://spring.io/projects/spring-data-jpa)
+- [Spring Security](https://spring.io/projects/spring-security)

package/kit/.claude/skills/backend-nodejs-express.md

@@ -0,0 +1,165 @@
+# Node.js Express Server
+
+Fast, unopinionated web application framework.
+
+## Setup
+
+```bash
+npm install express dotenv cors
+npm install -D nodemon
+```
+
+## Basic Server
+
+```typescript
+import express, { Express, Request, Response } from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const app: Express = express();
+const PORT = process.env.PORT || 3000;
+
+// Middleware
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+app.use(cors());
+
+// Routes
+app.get('/', (req: Request, res: Response) => {
+  res.json({ message: 'Hello World' });
+});
+
+app.get('/api/users', async (req: Request, res: Response) => {
+  try {
+    const users = await db.users.find();
+    res.json(users);
+  } catch (error) {
+    res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+app.post('/api/users', async (req: Request, res: Response) => {
+  const { email, name } = req.body;
+
+  if (!email || !name) {
+    return res.status(400).json({ error: 'Missing required fields' });
+  }
+
+  try {
+    const user = await db.users.create({ email, name });
+    res.status(201).json(user);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to create user' });
+  }
+});
+
+// 404 handler
+app.use((req: Request, res: Response) => {
+  res.status(404).json({ error: 'Route not found' });
+});
+
+// Error handler
+app.use((err: any, req: Request, res: Response) => {
+  console.error(err);
+  res.status(err.statusCode || 500).json({
+    error: err.message || 'Internal server error'
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});
+```
+
+## Routing
+
+```typescript
+import { Router } from 'express';
+
+const userRouter = Router();
+
+userRouter.get('/', async (req, res) => {
+  const users = await db.users.find();
+  res.json(users);
+});
+
+userRouter.get('/:id', async (req, res) => {
+  const user = await db.users.findById(req.params.id);
+  if (!user) return res.status(404).json({ error: 'Not found' });
+  res.json(user);
+});
+
+userRouter.post('/', async (req, res) => {
+  const user = await db.users.create(req.body);
+  res.status(201).json(user);
+});
+
+userRouter.patch('/:id', async (req, res) => {
+  const user = await db.users.update(req.params.id, req.body);
+  res.json(user);
+});
+
+userRouter.delete('/:id', async (req, res) => {
+  await db.users.delete(req.params.id);
+  res.status(204).send();
+});
+
+app.use('/api/users', userRouter);
+```
+
+## Middleware
+
+```typescript
+// Authentication middleware
+const authenticate = (req: any, res: Response, next: Function) => {
+  const token = req.headers.authorization?.split(' ')[1];
+
+  if (!token) {
+    return res.status(401).json({ error: 'Unauthorized' });
+  }
+
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
+    req.user = decoded;
+    next();
+  } catch (error) {
+    res.status(401).json({ error: 'Invalid token' });
+  }
+};
+
+// Logging middleware
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.path}`);
+  next();
+});
+
+// Rate limiting
+import rateLimit from 'express-rate-limit';
+
+const limiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 100
+});
+
+app.use('/api/', limiter);
+
+// Protected route
+app.get('/api/protected', authenticate, (req: any, res) => {
+  res.json({ message: 'Protected data', user: req.user });
+});
+```
+
+## Best Practices
+
+✅ **Structure** - Separate routes, controllers, services
+✅ **Error handling** - Global error handler
+✅ **Validation** - Validate input data
+✅ **Logging** - Log requests and errors
+✅ **Security** - CORS, rate limiting, input sanitization
+
+## Resources
+
+- [Express Documentation](https://expressjs.com/)
+- [Express Best Practices](https://expressjs.com/en/advanced/best-practice-security.html)

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

@@ -0,0 +1,143 @@
+# Node.js
+
+JavaScript runtime for building scalable backend services with async/await and event-driven architecture.
+
+## Event Loop & Async Model
+
+Node.js uses a non-blocking, event-driven architecture:
+- **Single-threaded**: Executes JavaScript in a single thread
+- **Non-blocking I/O**: File/network operations don't block execution
+- **Callbacks/Promises/Async-Await**: Handle asynchronous operations
+- **libuv**: Handles actual async work with thread pool
+
+### Async Patterns
+
+```javascript
+// Callbacks (avoid - callback hell)
+fs.readFile('file.txt', (err, data) => {
+  if (err) throw err;
+  console.log(data);
+});
+
+// Promises (better)
+fs.promises.readFile('file.txt')
+  .then(data => console.log(data))
+  .catch(err => console.error(err));
+
+// Async-Await (best - looks synchronous)
+async function readFile() {
+  try {
+    const data = await fs.promises.readFile('file.txt');
+    console.log(data);
+  } catch (err) {
+    console.error(err);
+  }
+}
+```
+
+## Core Modules
+
+### HTTP Server
+```javascript
+const http = require('http');
+
+const server = http.createServer((req, res) => {
+  if (req.url === '/' && req.method === 'GET') {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('Hello, World!');
+  } else {
+    res.writeHead(404);
+    res.end();
+  }
+});
+
+server.listen(3000);
+```
+
+### File System
+```javascript
+const fs = require('fs').promises;
+
+// Read file
+const content = await fs.readFile('file.txt', 'utf-8');
+
+// Write file
+await fs.writeFile('file.txt', 'content');
+
+// List files
+const files = await fs.readdir('.');
+```
+
+### Streams (for large data)
+```javascript
+// Read file in chunks
+const readStream = fs.createReadStream('large-file.txt');
+readStream.on('data', chunk => {
+  console.log(`Chunk size: ${chunk.length}`);
+});
+
+// Pipe (chain streams)
+fs.createReadStream('input.txt')
+  .pipe(zlib.createGzip())
+  .pipe(fs.createWriteStream('input.txt.gz'));
+```
+
+## Best Practices
+
+1. **Error Handling**
+   - Always catch promise rejections
+   - Use try-catch in async functions
+   - Handle uncaught exceptions at app level
+
+2. **Performance**
+   - Use async operations, never block event loop
+   - Cache expensive operations
+   - Use clustering for CPU-bound work
+   - Monitor event loop lag
+
+3. **Security**
+   - Validate all input
+   - Use environment variables for secrets
+   - Implement rate limiting
+   - Use HTTPS in production
+   - Keep dependencies updated
+
+4. **Memory Management**
+   - Avoid memory leaks (remove event listeners)
+   - Monitor heap usage
+   - Use streams for large files/data
+   - Be careful with circular references
+
+## Environment
+
+```javascript
+// Access environment variables
+const port = process.env.PORT || 3000;
+const nodeEnv = process.env.NODE_ENV || 'development';
+
+// .env file (use dotenv package)
+require('dotenv').config();
+```
+
+## Clustering
+
+```javascript
+const cluster = require('cluster');
+const os = require('os');
+
+if (cluster.isMaster) {
+  // Fork worker processes
+  for (let i = 0; i < os.cpus().length; i++) {
+    cluster.fork();
+  }
+} else {
+  // Worker process
+  require('./server.js').start();
+}
+```
+
+## Resources
+
+- [Node.js Official Docs](https://nodejs.org/docs)
+- [Event Loop Guide](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/)
+- [Streams Documentation](https://nodejs.org/api/stream.html)