claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/i18n-localization.md

@@ -0,0 +1,191 @@
+# Internationalization (i18n)
+
+Multi-language and locale support for applications.
+
+## Setup (Next.js)
+
+```bash
+npm install next-intl
+```
+
+## Configuration
+
+```typescript
+// i18n.config.ts
+import { getRequestConfig } from 'next-intl/server';
+
+export default getRequestConfig(async ({ locale }) => ({
+  messages: (await import(`./messages/${locale}.json`)).default
+}));
+```
+
+```json
+// messages/en.json
+{
+  "header": {
+    "welcome": "Welcome",
+    "login": "Login",
+    "logout": "Logout"
+  },
+  "common": {
+    "home": "Home",
+    "about": "About",
+    "contact": "Contact"
+  },
+  "errors": {
+    "notFound": "Not found"
+  }
+}
+```
+
+## React Components
+
+```typescript
+import { useTranslations } from 'next-intl';
+import { useLocale } from 'next-intl';
+
+export function Header() {
+  const t = useTranslations('header');
+  const locale = useLocale();
+
+  return (
+    <header>
+      <h1>{t('welcome')}</h1>
+      <div>Current language: {locale}</div>
+      <Link href="/en/home">{t('home')}</Link>
+      <Link href="/es/home">Inicio</Link>
+    </header>
+  );
+}
+
+export function ProductCard({ product }: { product: any }) {
+  const t = useTranslations('products');
+
+  return (
+    <div>
+      <h2>{t('title', { name: product.name })}</h2>
+      <p>{t('price', { price: product.price })}</p>
+    </div>
+  );
+}
+```
+
+## Dynamic Messages with Parameters
+
+```json
+{
+  "products": {
+    "title": "{name} Product",
+    "price": "Price: ${price}",
+    "rating": "{count, plural, =0 {No ratings} one {1 rating} other {# ratings}}"
+  }
+}
+```
+
+## Date & Number Formatting
+
+```typescript
+import { useFormatter } from 'next-intl';
+
+export function PriceDisplay({ amount }: { amount: number }) {
+  const format = useFormatter();
+
+  return (
+    <div>
+      Price: {format.number(amount, {
+        style: 'currency',
+        currency: 'USD'
+      })}
+    </div>
+  );
+}
+
+export function DateDisplay({ date }: { date: Date }) {
+  const format = useFormatter();
+
+  return (
+    <time>
+      {format.dateTime(date, {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric'
+      })}
+    </time>
+  );
+}
+```
+
+## URL Routing
+
+```typescript
+// middleware.ts
+import createMiddleware from 'next-intl/middleware';
+
+export default createMiddleware({
+  locales: ['en', 'es', 'fr', 'de'],
+  defaultLocale: 'en'
+});
+
+// Config matching paths
+export const config = {
+  matcher: ['/((?!api|_next|.*\\..*).*)']
+};
+```
+
+## Server-Side Translations
+
+```typescript
+import { getTranslations } from 'next-intl/server';
+
+export async function generateMetadata({ locale }: any) {
+  const t = await getTranslations({ locale, namespace: 'metadata' });
+
+  return {
+    title: t('title'),
+    description: t('description')
+  };
+}
+```
+
+## Language Switcher
+
+```typescript
+import Link from 'next/link';
+import { usePathname } from 'next/navigation';
+
+export function LanguageSwitcher() {
+  const pathname = usePathname();
+
+  const languages = [
+    { code: 'en', name: 'English' },
+    { code: 'es', name: 'Español' },
+    { code: 'fr', name: 'Français' }
+  ];
+
+  return (
+    <select onChange={(e) => {
+      const newPath = pathname.replace(/^\/[a-z]{2}/, `/${e.target.value}`);
+      // Navigate
+    }}>
+      {languages.map(lang => (
+        <option key={lang.code} value={lang.code}>
+          {lang.name}
+        </option>
+      ))}
+    </select>
+  );
+}
+```
+
+## Best Practices
+
+✅ **Namespace translations** - Organize by feature/page
+✅ **Use placeholders** - For dynamic values
+✅ **RTL support** - Test with right-to-left languages
+✅ **Translation management** - Use Crowdin or similar
+✅ **SEO optimization** - Use hreflang for language variants
+
+## Resources
+
+- [next-intl Documentation](https://next-intl-docs.vercel.app/)
+- [ICU Message Syntax](https://unicode-org.github.io/icu/userguide/format_parse/messages/)

package/kit/.claude/skills/i18n-nextjs.md

@@ -0,0 +1,127 @@
+# Next.js i18n
+
+## Overview
+Add internationalization to Next.js with next-intl for type-safe translations and locale routing.
+
+## Setup with next-intl
+
+```bash
+npm install next-intl
+```
+
+```
+messages/
+├── en.json
+├── es.json
+└── ja.json
+app/
+├── [locale]/
+│   ├── layout.tsx
+│   └── page.tsx
+└── i18n.ts
+```
+
+## Configuration
+
+```typescript
+// i18n.ts
+import { getRequestConfig } from 'next-intl/server';
+
+export default getRequestConfig(async ({ locale }) => ({
+  messages: (await import(`./messages/${locale}.json`)).default
+}));
+```
+
+```typescript
+// middleware.ts
+import createMiddleware from 'next-intl/middleware';
+
+export default createMiddleware({
+  locales: ['en', 'es', 'ja'],
+  defaultLocale: 'en',
+});
+
+export const config = { matcher: ['/((?!api|_next|.*\..*).*)'] };
+```
+
+## Translation Files
+
+```json
+// messages/en.json
+{
+  "HomePage": {
+    "title": "Welcome to {appName}",
+    "description": "A Next.js app with i18n"
+  },
+  "Common": {
+    "save": "Save",
+    "items": "{count, plural, one {# item} other {# items}}"
+  }
+}
+```
+
+## Server Component Usage
+
+```tsx
+// app/[locale]/page.tsx
+import { useTranslations } from 'next-intl';
+import { setRequestLocale } from 'next-intl/server';
+
+export default function HomePage({ params: { locale } }: { params: { locale: string } }) {
+  setRequestLocale(locale);
+  const t = useTranslations('HomePage');
+
+  return (
+    <main>
+      <h1>{t('title', { appName: 'My App' })}</h1>
+      <p>{t('description')}</p>
+    </main>
+  );
+}
+
+export function generateStaticParams() {
+  return ['en', 'es', 'ja'].map(locale => ({ locale }));
+}
+```
+
+## Client Component Usage
+
+```tsx
+'use client';
+import { useTranslations } from 'next-intl';
+
+export function SaveButton() {
+  const t = useTranslations('Common');
+  return <button>{t('save')}</button>;
+}
+```
+
+## Locale Switcher
+
+```tsx
+'use client';
+import { useRouter, usePathname } from 'next/navigation';
+
+export function LocaleSwitcher({ locale }: { locale: string }) {
+  const router = useRouter();
+  const pathname = usePathname();
+  const locales = ['en', 'es', 'ja'];
+
+  return (
+    <select value={locale} onChange={e => {
+      const newPath = pathname.replace(`/${locale}`, `/${e.target.value}`);
+      router.replace(newPath);
+    }}>
+      {locales.map(l => <option key={l} value={l}>{l.toUpperCase()}</option>)}
+    </select>
+  );
+}
+```
+
+## Best Practices
+- Use `setRequestLocale` in server components for static rendering
+- Use `generateStaticParams` to pre-render all locale variants
+- Keep translation keys hierarchical: `HomePage.title`, `Common.save`
+
+## Resources
+- [next-intl docs](https://next-intl-docs.vercel.app)

package/kit/.claude/skills/infrastructure-docker-compose.md

@@ -0,0 +1,77 @@
+# Docker Compose
+
+Multi-container application orchestration.
+
+## Basic Setup
+
+```yaml
+version: '3.9'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
+      - REDIS_URL=redis://cache:6379
+    depends_on:
+      - db
+      - cache
+    volumes:
+      - .:/app
+      - /app/node_modules
+
+  db:
+    image: postgres:15
+    environment:
+      - POSTGRES_USER=user
+      - POSTGRES_PASSWORD=pass
+      - POSTGRES_DB=myapp
+    volumes:
+      - db_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+
+  cache:
+    image: redis:7
+    ports:
+      - "6379:6379"
+
+volumes:
+  db_data:
+```
+
+## Commands
+
+```bash
+# Start services
+docker-compose up
+
+# Start in background
+docker-compose up -d
+
+# View logs
+docker-compose logs -f
+
+# Execute command in container
+docker-compose exec app npm run migrate
+
+# Stop services
+docker-compose down
+
+# Remove volumes
+docker-compose down -v
+```
+
+## Best Practices
+
+✅ **Volume mapping** - Persist data
+✅ **Environment variables** - Configuration
+✅ **Depends_on** - Service ordering
+✅ **Health checks** - Monitor services
+✅ **Networks** - Service communication
+
+## Resources
+
+- [Docker Compose Documentation](https://docs.docker.com/compose/)

package/kit/.claude/skills/infrastructure-serverless.md

@@ -0,0 +1,177 @@
+# Serverless Computing
+
+Building applications without managing servers.
+
+## AWS Lambda
+
+```typescript
+// Handler function
+export const handler = async (event: any) => {
+  console.log('Event:', event);
+
+  try {
+    // Process event
+    const result = await processData(event.body);
+
+    return {
+      statusCode: 200,
+      body: JSON.stringify(result)
+    };
+  } catch (error) {
+    console.error('Error:', error);
+
+    return {
+      statusCode: 500,
+      body: JSON.stringify({ error: 'Internal error' })
+    };
+  }
+};
+
+// With dependencies
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+
+const s3 = new S3Client();
+
+export const s3Handler = async (event: S3Event) => {
+  for (const record of event.Records) {
+    const bucket = record.s3.bucket.name;
+    const key = record.s3.object.key;
+
+    const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+    const response = await s3.send(command);
+
+    // Process object
+  }
+};
+```
+
+## Google Cloud Functions
+
+```typescript
+import functions from '@google-cloud/functions-framework';
+
+functions.http('helloWorld', (req, res) => {
+  const name = req.query.name || 'World';
+  res.send(`Hello ${name}!`);
+});
+
+// Async function
+functions.http('asyncFunction', async (req, res) => {
+  const data = await fetchData();
+  res.json(data);
+});
+
+// Pub/Sub trigger
+functions.cloud.pubsub('processPubSub', (message) => {
+  const data = Buffer.from(message.data, 'base64').toString();
+  console.log('Received:', data);
+});
+```
+
+## Azure Functions
+
+```typescript
+import { AzureFunction, Context, HttpRequest } from '@azure/functions';
+
+const httpTrigger: AzureFunction = async (
+  context: Context,
+  req: HttpRequest
+): Promise<void> => {
+  context.log('HTTP trigger function processed a request.');
+
+  const name = req.query.name || req.body?.name || 'World';
+
+  context.res = {
+    status: 200,
+    body: `Hello, ${name}!`
+  };
+};
+
+export default httpTrigger;
+
+// Timer trigger
+const timerTrigger: AzureFunction = async (context: Context) => {
+  const timeStamp = new Date().toISOString();
+  context.log('Timer trigger function ran!', timeStamp);
+};
+
+export default timerTrigger;
+```
+
+## Deployment
+
+```bash
+# AWS SAM
+sam init
+sam build
+sam deploy
+
+# Google Cloud
+gcloud functions deploy myFunction \
+  --runtime nodejs20 \
+  --trigger-http
+
+# Azure Functions
+func new
+func start
+func azure functionapp publish <FunctionAppName>
+```
+
+## Local Development
+
+```bash
+# AWS SAM local
+sam local start-api
+
+# Google Cloud Functions Framework
+functions-framework --target=myFunction --debug
+
+# Azure Functions Core Tools
+func start
+```
+
+## Monitoring & Logging
+
+```typescript
+// CloudWatch logging
+console.log('Info message');
+console.error('Error message');
+
+// Structured logging
+console.log(JSON.stringify({
+  timestamp: new Date().toISOString(),
+  level: 'INFO',
+  message: 'Processing event',
+  eventId: event.id
+}));
+
+// Custom metrics
+import { CloudWatch } from 'aws-sdk';
+
+const cw = new CloudWatch();
+
+await cw.putMetricData({
+  Namespace: 'MyApp',
+  MetricData: [
+    {
+      MetricName: 'ProcessingTime',
+      Value: duration,
+      Unit: 'Milliseconds'
+    }
+  ]
+}).promise();
+```
+
+## Best Practices
+
+✅ **Keep functions small** - Single responsibility
+✅ **Optimize cold starts** - Minimize dependencies
+✅ **Handle errors** - Return proper status codes
+✅ **Set timeouts** - Prevent hanging functions
+✅ **Monitor costs** - Track function executions
+
+## Resources
+
+- [AWS Lambda Documentation](https://docs.aws.amazon.com/lambda/)
+- [Google Cloud Functions](https://cloud.google.com/functions/docs)
+- [Azure Functions](https://docs.microsoft.com/en-us/azure/azure-functions/)

package/kit/.claude/skills/jwt-tokens.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