claudeinone-cli 1.0.1 → 1.0.3

package/kit/.claude/skills/mobile-flutter.md

@@ -0,0 +1,259 @@
+# Flutter
+
+Google's cross-platform framework for mobile, web, and desktop.
+
+## Setup
+
+```bash
+flutter create my_app
+cd my_app
+flutter pub add http provider
+flutter run
+```
+
+## Basic Widget
+
+```dart
+import 'package:flutter/material.dart';
+
+void main() {
+  runApp(const MyApp());
+}
+
+class MyApp extends StatelessWidget {
+  const MyApp({Key? key}) : super(key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      home: const HomeScreen(),
+    );
+  }
+}
+
+class HomeScreen extends StatefulWidget {
+  const HomeScreen({Key? key}) : super(key: key);
+
+  @override
+  State<HomeScreen> createState() => _HomeScreenState();
+}
+
+class _HomeScreenState extends State<HomeScreen> {
+  int count = 0;
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: const Text('Counter')),
+      body: Center(
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Text('Count: $count'),
+            ElevatedButton(
+              onPressed: () => setState(() => count++),
+              child: const Text('Increment'),
+            )
+          ],
+        ),
+      ),
+    );
+  }
+}
+```
+
+## API Integration
+
+```dart
+import 'package:http/http.dart' as http;
+import 'dart:convert';
+
+class User {
+  final String id;
+  final String email;
+  final String name;
+
+  User({
+    required this.id,
+    required this.email,
+    required this.name,
+  });
+
+  factory User.fromJson(Map<String, dynamic> json) {
+    return User(
+      id: json['id'],
+      email: json['email'],
+      name: json['name'],
+    );
+  }
+}
+
+class ApiClient {
+  static const String baseUrl = 'https://api.example.com';
+
+  static Future<List<User>> getUsers() async {
+    final response = await http.get(
+      Uri.parse('$baseUrl/users'),
+    );
+
+    if (response.statusCode == 200) {
+      final List<dynamic> json = jsonDecode(response.body);
+      return json.map((item) => User.fromJson(item)).toList();
+    } else {
+      throw Exception('Failed to load users');
+    }
+  }
+
+  static Future<User> createUser(String email, String name) async {
+    final response = await http.post(
+      Uri.parse('$baseUrl/users'),
+      headers: {'Content-Type': 'application/json'},
+      body: jsonEncode({'email': email, 'name': name}),
+    );
+
+    if (response.statusCode == 201) {
+      return User.fromJson(jsonDecode(response.body));
+    } else {
+      throw Exception('Failed to create user');
+    }
+  }
+}
+```
+
+## Provider State Management
+
+```dart
+import 'package:provider/provider.dart';
+
+class AuthNotifier extends ChangeNotifier {
+  User? _user;
+
+  User? get user => _user;
+
+  Future<void> login(String email, String password) async {
+    try {
+      final response = await http.post(
+        Uri.parse('https://api.example.com/auth/login'),
+        body: {'email': email, 'password': password},
+      );
+
+      if (response.statusCode == 200) {
+        _user = User.fromJson(jsonDecode(response.body));
+        notifyListeners();
+      }
+    } catch (e) {
+      rethrow;
+    }
+  }
+
+  void logout() {
+    _user = null;
+    notifyListeners();
+  }
+}
+
+class LoginScreen extends StatefulWidget {
+  @override
+  State<LoginScreen> createState() => _LoginScreenState();
+}
+
+class _LoginScreenState extends State<LoginScreen> {
+  late TextEditingController emailController;
+  late TextEditingController passwordController;
+
+  @override
+  void initState() {
+    super.initState();
+    emailController = TextEditingController();
+    passwordController = TextEditingController();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: const Text('Login')),
+      body: Padding(
+        padding: const EdgeInsets.all(16.0),
+        child: Column(
+          children: [
+            TextField(
+              controller: emailController,
+              decoration: const InputDecoration(labelText: 'Email'),
+            ),
+            TextField(
+              controller: passwordController,
+              obscureText: true,
+              decoration: const InputDecoration(labelText: 'Password'),
+            ),
+            ElevatedButton(
+              onPressed: () async {
+                await context.read<AuthNotifier>().login(
+                  emailController.text,
+                  passwordController.text,
+                );
+              },
+              child: const Text('Login'),
+            )
+          ],
+        ),
+      ),
+    );
+  }
+}
+```
+
+## Navigation
+
+```dart
+class AppRouter {
+  static Route<dynamic> generateRoute(RouteSettings settings) {
+    switch (settings.name) {
+      case '/':
+        return MaterialPageRoute(builder: (_) => const HomeScreen());
+      case '/login':
+        return MaterialPageRoute(builder: (_) => const LoginScreen());
+      case '/profile':
+        return MaterialPageRoute(builder: (_) => const ProfileScreen());
+      default:
+        return MaterialPageRoute(
+          builder: (_) => Scaffold(
+            body: Center(child: Text('No route for ${settings.name}')),
+          ),
+        );
+    }
+  }
+}
+
+// In MyApp:
+onGenerateRoute: AppRouter.generateRoute,
+```
+
+## Build & Deploy
+
+```bash
+# Build APK
+flutter build apk
+
+# Build iOS
+flutter build ios
+
+# Build web
+flutter build web
+
+# Test
+flutter test
+```
+
+## Best Practices
+
+✅ **Use Provider** - State management pattern
+✅ **Hot reload** - Fast development cycle
+✅ **Bloc pattern** - Complex state management
+✅ **Testing** - Unit, widget, and integration tests
+✅ **Performance** - Use RepaintBoundary, const widgets
+
+## Resources
+
+- [Flutter Official](https://flutter.dev/)
+- [Flutter Docs](https://docs.flutter.dev/)
+- [Provider Package](https://pub.dev/packages/provider)

package/kit/.claude/skills/mobile-react-native.md

@@ -0,0 +1,238 @@
+# React Native
+
+Cross-platform mobile development with JavaScript/TypeScript.
+
+## Setup
+
+```bash
+npm install -g eas-cli
+npx create-expo-app my-app
+cd my-app
+npm install react-native-paper axios react-navigation
+```
+
+## Basic Components
+
+```typescript
+import React from 'react';
+import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    backgroundColor: '#f5f5f5'
+  },
+  text: {
+    fontSize: 18,
+    marginBottom: 20,
+    color: '#333'
+  },
+  button: {
+    backgroundColor: '#007AFF',
+    paddingHorizontal: 20,
+    paddingVertical: 10,
+    borderRadius: 8
+  },
+  buttonText: {
+    color: '#fff',
+    fontSize: 16,
+    fontWeight: 'bold'
+  }
+});
+
+export default function HomeScreen() {
+  const [count, setCount] = React.useState(0);
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.text}>Count: {count}</Text>
+      
+      <TouchableOpacity 
+        style={styles.button}
+        onPress={() => setCount(count + 1)}
+      >
+        <Text style={styles.buttonText}>Increment</Text>
+      </TouchableOpacity>
+    </View>
+  );
+}
+```
+
+## Navigation
+
+```typescript
+import { NavigationContainer } from '@react-navigation/native';
+import { createNativeStackNavigator } from '@react-navigation/native-stack';
+import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
+
+const Stack = createNativeStackNavigator();
+const Tab = createBottomTabNavigator();
+
+function HomeStack() {
+  return (
+    <Stack.Navigator>
+      <Stack.Screen 
+        name="Home" 
+        component={HomeScreen}
+        options={{ title: 'Home' }}
+      />
+      <Stack.Screen 
+        name="Details" 
+        component={DetailsScreen}
+      />
+    </Stack.Navigator>
+  );
+}
+
+function SettingsStack() {
+  return (
+    <Stack.Navigator>
+      <Stack.Screen name="Settings" component={SettingsScreen} />
+    </Stack.Navigator>
+  );
+}
+
+export default function App() {
+  return (
+    <NavigationContainer>
+      <Tab.Navigator>
+        <Tab.Screen name="HomeTab" component={HomeStack} />
+        <Tab.Screen name="SettingsTab" component={SettingsStack} />
+      </Tab.Navigator>
+    </NavigationContainer>
+  );
+}
+```
+
+## API Integration
+
+```typescript
+import axios from 'axios';
+import { useEffect, useState } from 'react';
+import { View, Text, FlatList, ActivityIndicator } from 'react-native';
+
+const api = axios.create({
+  baseURL: 'https://api.example.com'
+});
+
+export function UserList() {
+  const [users, setUsers] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    fetchUsers();
+  }, []);
+
+  async function fetchUsers() {
+    try {
+      const response = await api.get('/users');
+      setUsers(response.data);
+    } catch (err) {
+      setError((err as Error).message);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  if (loading) return <ActivityIndicator />;
+  if (error) return <Text>Error: {error}</Text>;
+
+  return (
+    <FlatList
+      data={users}
+      renderItem={({ item }) => <Text>{item.name}</Text>}
+      keyExtractor={item => item.id}
+    />
+  );
+}
+```
+
+## State Management (Context + Hooks)
+
+```typescript
+import { createContext, useContext, useState } from 'react';
+
+interface AuthContextType {
+  user: User | null;
+  login: (email: string, password: string) => Promise<void>;
+  logout: () => void;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export function AuthProvider({ children }: { children: React.ReactNode }) {
+  const [user, setUser] = useState<User | null>(null);
+
+  async function login(email: string, password: string) {
+    const response = await api.post('/auth/login', { email, password });
+    setUser(response.data.user);
+  }
+
+  function logout() {
+    setUser(null);
+  }
+
+  return (
+    <AuthContext.Provider value={{ user, login, logout }}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error('useAuth must be used within AuthProvider');
+  }
+  return context;
+}
+```
+
+## Native Modules (iOS/Android)
+
+```typescript
+import { NativeModules } from 'react-native';
+
+const { CameraModule } = NativeModules;
+
+export async function takePicture() {
+  try {
+    const result = await CameraModule.takePicture({
+      quality: 0.8
+    });
+    return result.uri;
+  } catch (error) {
+    console.error('Camera error:', error);
+  }
+}
+```
+
+## Build & Deploy
+
+```bash
+# Build APK for Android
+eas build --platform android --local
+
+# Build IPA for iOS
+eas build --platform ios --local
+
+# Submit to app store
+eas submit --platform ios --latest
+```
+
+## Best Practices
+
+✅ **Use FlatList** - For performant lists
+✅ **Native modules** - For performance-critical code
+✅ **Avoid inline styles** - Use StyleSheet.create()
+✅ **Test on real devices** - Simulator doesn't catch all issues
+✅ **Handle permissions** - Camera, location, contacts
+
+## Resources
+
+- [React Native Docs](https://reactnative.dev/)
+- [Expo Documentation](https://docs.expo.dev/)
+- [React Navigation](https://reactnavigation.org/)

package/kit/.claude/skills/monitoring-apm.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