autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/vue.md

@@ -0,0 +1,202 @@
+# Vue 3 Skill (Composition API)
+
+## Component Structure
+\`\`\`vue
+<script setup lang="ts">
+import { ref, computed, watch, onMounted } from 'vue';
+
+// Props with defaults
+const props = withDefaults(defineProps<{
+  userId: string;
+  initialCount?: number;
+}>(), {
+  initialCount: 0
+});
+
+// Emits with validation
+const emit = defineEmits<{
+  (e: 'update', value: number): void;
+  (e: 'submit', data: FormData): void;
+}>();
+
+// Reactive State
+const count = ref(props.initialCount);
+const user = ref<User | null>(null);
+
+// Computed
+const doubleCount = computed(() => count.value * 2);
+
+// Methods
+function increment() {
+  count.value++;
+  emit('update', count.value);
+}
+
+// Lifecycle
+onMounted(async () => {
+  user.value = await fetchUser(props.userId);
+});
+</script>
+
+<template>
+  <div>
+    <h2>{{ user?.name }}</h2>
+    <p>Count: {{ count }} (Double: {{ doubleCount }})</p>
+    <button @click="increment">Increment</button>
+  </div>
+</template>
+\`\`\`
+
+## Composables (Custom Hooks)
+\`\`\`typescript
+// composables/useUser.ts
+import { ref, onMounted } from 'vue';
+
+export function useUser(userId: Ref<string>) {
+  const user = ref<User | null>(null);
+  const loading = ref(true);
+  const error = ref<Error | null>(null);
+
+  async function fetchUser() {
+    loading.value = true;
+    try {
+      user.value = await api.getUser(userId.value);
+    } catch (e) {
+      error.value = e as Error;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  // Refetch when userId changes
+  watch(userId, fetchUser, { immediate: true });
+
+  return { user, loading, error, refetch: fetchUser };
+}
+
+// Usage in component
+const { user, loading, error } = useUser(toRef(props, 'userId'));
+\`\`\`
+
+## Watch & WatchEffect
+\`\`\`typescript
+// Watch specific ref
+watch(count, (newVal, oldVal) => {
+  console.log(\`Count changed from \${oldVal} to \${newVal}\`);
+});
+
+// Watch multiple sources
+watch([firstName, lastName], ([first, last]) => {
+  fullName.value = \`\${first} \${last}\`;
+});
+
+// Deep watch for objects
+watch(user, (newUser) => {
+  saveToLocalStorage(newUser);
+}, { deep: true });
+
+// WatchEffect - auto-tracks dependencies
+watchEffect(() => {
+  // Automatically re-runs when user.value or count.value changes
+  console.log(\`User: \${user.value?.name}, Count: \${count.value}\`);
+});
+
+// Cleanup
+watchEffect((onCleanup) => {
+  const timer = setInterval(() => tick(), 1000);
+  onCleanup(() => clearInterval(timer));
+});
+\`\`\`
+
+## Provide/Inject (Dependency Injection)
+\`\`\`typescript
+// Parent component (provide)
+import { provide, ref } from 'vue';
+
+const theme = ref('dark');
+const toggleTheme = () => {
+  theme.value = theme.value === 'dark' ? 'light' : 'dark';
+};
+
+provide('theme', { theme, toggleTheme });
+
+// Child component (inject)
+import { inject } from 'vue';
+
+const { theme, toggleTheme } = inject('theme')!;
+
+// With TypeScript - define injection key
+// types/injection-keys.ts
+import type { InjectionKey, Ref } from 'vue';
+
+export const ThemeKey: InjectionKey<{
+  theme: Ref<string>;
+  toggleTheme: () => void;
+}> = Symbol('theme');
+\`\`\`
+
+## v-model Customization
+\`\`\`vue
+<script setup lang="ts">
+// Single v-model
+const modelValue = defineModel<string>();
+
+// Named v-model with modifier
+const [firstName, firstNameModifiers] = defineModel<string>('firstName');
+const [lastName] = defineModel<string>('lastName');
+
+// Usage: <MyInput v-model:firstName="first" v-model:lastName="last" />
+</script>
+
+<template>
+  <input :value="modelValue" @input="modelValue = $event.target.value" />
+</template>
+\`\`\`
+
+## Slots
+\`\`\`vue
+<!-- Parent -->
+<Card>
+  <template #header>
+    <h1>Title</h1>
+  </template>
+
+  <template #default="{ item }">
+    <p>{{ item.name }}</p>
+  </template>
+
+  <template #footer>
+    <button>Submit</button>
+  </template>
+</Card>
+
+<!-- Card.vue -->
+<template>
+  <div class="card">
+    <header>
+      <slot name="header" />
+    </header>
+    <main>
+      <slot :item="currentItem" />
+    </main>
+    <footer>
+      <slot name="footer" />
+    </footer>
+  </div>
+</template>
+\`\`\`
+
+## ❌ DON'T
+- Mutate props directly
+- Forget to use .value with refs in script
+- Use reactive() for primitives (use ref)
+- Create watchers without cleanup when needed
+- Overuse provide/inject (prefer props for direct parent-child)
+
+## ✅ DO
+- Use \`<script setup>\` for cleaner code
+- Use TypeScript for props/emits
+- Create composables for reusable logic
+- Use computed for derived state
+- Use watchEffect for side effects with auto-tracking
+- Provide injection keys with TypeScript

package/.claude/skills/warp.md

@@ -0,0 +1,365 @@
+# Warp Framework Skill
+
+## Application Setup
+\`\`\`rust
+use warp::Filter;
+use std::net::SocketAddr;
+
+#[tokio::main]
+async fn main() {
+    // Initialize tracing
+    tracing_subscriber::fmt::init();
+
+    // Create shared state
+    let db_pool = create_pool().await.expect("Failed to create pool");
+    let state = AppState { db: db_pool };
+
+    // Build routes
+    let routes = api_routes(state)
+        .with(warp::trace::request());
+
+    let addr: SocketAddr = "127.0.0.1:3000".parse().unwrap();
+    tracing::info!("Listening on {}", addr);
+
+    warp::serve(routes).run(addr).await;
+}
+
+fn api_routes(state: AppState) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
+    let api = warp::path("api").and(warp::path("v1"));
+
+    api.and(
+        auth_routes(state.clone())
+            .or(user_routes(state.clone()))
+            .or(post_routes(state))
+    )
+    .recover(handle_rejection)
+}
+\`\`\`
+
+## Route Definitions with Filters
+\`\`\`rust
+use warp::{Filter, Reply, Rejection};
+
+fn user_routes(state: AppState) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone {
+    let users = warp::path("users");
+
+    let list = users
+        .and(warp::path::end())
+        .and(warp::get())
+        .and(with_state(state.clone()))
+        .and(warp::query::<PaginationQuery>())
+        .and_then(list_users);
+
+    let create = users
+        .and(warp::path::end())
+        .and(warp::post())
+        .and(with_state(state.clone()))
+        .and(warp::body::json())
+        .and_then(create_user);
+
+    let get = users
+        .and(warp::path::param::<String>())
+        .and(warp::path::end())
+        .and(warp::get())
+        .and(with_state(state.clone()))
+        .and_then(get_user);
+
+    let update = users
+        .and(warp::path::param::<String>())
+        .and(warp::path::end())
+        .and(warp::put())
+        .and(with_state(state.clone()))
+        .and(warp::body::json())
+        .and_then(update_user);
+
+    let delete = users
+        .and(warp::path::param::<String>())
+        .and(warp::path::end())
+        .and(warp::delete())
+        .and(with_state(state))
+        .and_then(delete_user);
+
+    list.or(create).or(get).or(update).or(delete)
+}
+
+// Protected routes with auth
+fn protected_routes(state: AppState) -> impl Filter<Extract = impl Reply, Error = Rejection> + Clone {
+    warp::path("protected")
+        .and(with_auth())
+        .and(with_state(state))
+        .and_then(protected_handler)
+}
+\`\`\`
+
+## Custom Filters
+\`\`\`rust
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub db: PgPool,
+}
+
+// State filter
+fn with_state(state: AppState) -> impl Filter<Extract = (AppState,), Error = std::convert::Infallible> + Clone {
+    warp::any().map(move || state.clone())
+}
+
+// Auth filter
+fn with_auth() -> impl Filter<Extract = (AuthUser,), Error = Rejection> + Clone {
+    warp::header::optional::<String>("Authorization")
+        .and_then(|auth_header: Option<String>| async move {
+            let token = auth_header
+                .as_ref()
+                .and_then(|h| h.strip_prefix("Bearer "))
+                .ok_or_else(|| warp::reject::custom(AppError::Unauthorized))?;
+
+            let claims = validate_token(token)
+                .map_err(|_| warp::reject::custom(AppError::Unauthorized))?;
+
+            Ok::<_, Rejection>(AuthUser {
+                user_id: claims.sub,
+                role: claims.role,
+            })
+        })
+}
+
+// Optional auth filter
+fn with_optional_auth() -> impl Filter<Extract = (Option<AuthUser>,), Error = Rejection> + Clone {
+    warp::header::optional::<String>("Authorization")
+        .map(|auth_header: Option<String>| {
+            auth_header
+                .as_ref()
+                .and_then(|h| h.strip_prefix("Bearer "))
+                .and_then(|token| validate_token(token).ok())
+                .map(|claims| AuthUser {
+                    user_id: claims.sub,
+                    role: claims.role,
+                })
+        })
+}
+
+// Request body size limit
+fn json_body<T: DeserializeOwned + Send>() -> impl Filter<Extract = (T,), Error = Rejection> + Clone {
+    warp::body::content_length_limit(1024 * 16)  // 16KB
+        .and(warp::body::json())
+}
+\`\`\`
+
+## Handlers
+\`\`\`rust
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+pub struct CreateUserRequest {
+    pub email: String,
+    pub name: String,
+    pub password: String,
+}
+
+#[derive(Deserialize, Default)]
+pub struct PaginationQuery {
+    #[serde(default = "default_page")]
+    pub page: u32,
+    #[serde(default = "default_per_page")]
+    pub per_page: u32,
+}
+
+fn default_page() -> u32 { 1 }
+fn default_per_page() -> u32 { 20 }
+
+async fn list_users(
+    state: AppState,
+    query: PaginationQuery,
+) -> Result<impl Reply, Rejection> {
+    let offset = (query.page - 1) * query.per_page;
+
+    let users = sqlx::query_as!(User,
+        "SELECT * FROM users LIMIT $1 OFFSET $2",
+        query.per_page as i64,
+        offset as i64
+    )
+    .fetch_all(&state.db)
+    .await
+    .map_err(|e| warp::reject::custom(AppError::Database(e)))?;
+
+    Ok(warp::reply::json(&users))
+}
+
+async fn get_user(id: String, state: AppState) -> Result<impl Reply, Rejection> {
+    let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
+        .fetch_optional(&state.db)
+        .await
+        .map_err(|e| warp::reject::custom(AppError::Database(e)))?
+        .ok_or_else(|| warp::reject::custom(AppError::NotFound))?;
+
+    Ok(warp::reply::json(&user))
+}
+
+async fn create_user(
+    state: AppState,
+    body: CreateUserRequest,
+) -> Result<impl Reply, Rejection> {
+    // Validate
+    if body.email.is_empty() {
+        return Err(warp::reject::custom(AppError::Validation("Email required".into())));
+    }
+
+    let user = User::new(&body.email, &body.name, &body.password)
+        .map_err(|e| warp::reject::custom(e))?;
+
+    // Save user...
+
+    Ok(warp::reply::with_status(
+        warp::reply::json(&user),
+        warp::http::StatusCode::CREATED,
+    ))
+}
+\`\`\`
+
+## Error Handling with Rejections
+\`\`\`rust
+use warp::{reject::Reject, Rejection, Reply};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum AppError {
+    #[error("Not found")]
+    NotFound,
+
+    #[error("Unauthorized")]
+    Unauthorized,
+
+    #[error("Validation error: {0}")]
+    Validation(String),
+
+    #[error("Database error")]
+    Database(#[from] sqlx::Error),
+}
+
+impl Reject for AppError {}
+
+#[derive(Serialize)]
+struct ErrorResponse {
+    error: String,
+}
+
+async fn handle_rejection(err: Rejection) -> Result<impl Reply, std::convert::Infallible> {
+    let (code, message) = if err.is_not_found() {
+        (warp::http::StatusCode::NOT_FOUND, "Not found".to_string())
+    } else if let Some(e) = err.find::<AppError>() {
+        match e {
+            AppError::NotFound => (warp::http::StatusCode::NOT_FOUND, e.to_string()),
+            AppError::Unauthorized => (warp::http::StatusCode::UNAUTHORIZED, e.to_string()),
+            AppError::Validation(_) => (warp::http::StatusCode::BAD_REQUEST, e.to_string()),
+            AppError::Database(_) => {
+                tracing::error!("Database error: {:?}", e);
+                (warp::http::StatusCode::INTERNAL_SERVER_ERROR, "Internal error".to_string())
+            }
+        }
+    } else if err.find::<warp::reject::MethodNotAllowed>().is_some() {
+        (warp::http::StatusCode::METHOD_NOT_ALLOWED, "Method not allowed".to_string())
+    } else if err.find::<warp::reject::InvalidQuery>().is_some() {
+        (warp::http::StatusCode::BAD_REQUEST, "Invalid query".to_string())
+    } else if err.find::<warp::reject::PayloadTooLarge>().is_some() {
+        (warp::http::StatusCode::PAYLOAD_TOO_LARGE, "Payload too large".to_string())
+    } else {
+        tracing::error!("Unhandled rejection: {:?}", err);
+        (warp::http::StatusCode::INTERNAL_SERVER_ERROR, "Internal error".to_string())
+    };
+
+    let json = warp::reply::json(&ErrorResponse { error: message });
+    Ok(warp::reply::with_status(json, code))
+}
+\`\`\`
+
+## CORS
+\`\`\`rust
+use warp::cors;
+
+fn with_cors() -> warp::cors::Builder {
+    warp::cors()
+        .allow_any_origin()
+        .allow_methods(vec!["GET", "POST", "PUT", "DELETE", "OPTIONS"])
+        .allow_headers(vec!["Authorization", "Content-Type"])
+        .max_age(3600)
+}
+
+// Apply to routes
+let routes = api_routes(state)
+    .with(with_cors())
+    .with(warp::trace::request());
+\`\`\`
+
+## Testing
+\`\`\`rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use warp::http::StatusCode;
+    use warp::test::request;
+
+    async fn create_test_state() -> AppState {
+        AppState {
+            db: create_test_pool().await,
+        }
+    }
+
+    #[tokio::test]
+    async fn test_get_user() {
+        let state = create_test_state().await;
+        let filter = user_routes(state);
+
+        let resp = request()
+            .method("GET")
+            .path("/users/123")
+            .reply(&filter)
+            .await;
+
+        assert_eq!(resp.status(), StatusCode::OK);
+    }
+
+    #[tokio::test]
+    async fn test_create_user() {
+        let state = create_test_state().await;
+        let filter = user_routes(state);
+
+        let resp = request()
+            .method("POST")
+            .path("/users")
+            .header("Content-Type", "application/json")
+            .body(r#"{"email":"test@example.com","name":"Test","password":"password123"}"#)
+            .reply(&filter)
+            .await;
+
+        assert_eq!(resp.status(), StatusCode::CREATED);
+    }
+
+    #[tokio::test]
+    async fn test_protected_without_auth() {
+        let state = create_test_state().await;
+        let filter = protected_routes(state).recover(handle_rejection);
+
+        let resp = request()
+            .method("GET")
+            .path("/protected")
+            .reply(&filter)
+            .await;
+
+        assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use filter combinators (\`.and()\`, \`.or()\`, \`.map()\`, \`.and_then()\`)
+- Implement \`Reject\` for custom error types
+- Use \`.recover()\` for centralized error handling
+- Use \`warp::trace\` for request logging
+- Clone state with \`Clone\` trait when composing routes
+
+## ❌ DON'T
+- Don't forget to handle all rejection types in recovery
+- Don't use \`.unwrap()\` in handlers
+- Don't create filters that are not \`Clone\` + \`Send\` + \`Sync\`
+- Don't expose internal errors to clients