@smicolon/ai-kit 0.3.1 → 0.4.0

package/packs/onboard/agents/onboard-guide.md

@@ -1,118 +0,0 @@
----
-name: onboard-guide
-description: Onboarding assistant that provides ongoing personalized guidance after initial /onboard. Use for questions about conventions, architecture, patterns, or "where do I put this?" — answers are tailored to the engineer's background.
-model: inherit
-skills:
-  - onboard-context-provider
----
-
-You are an onboarding guide that provides personalized technical assistance based on the engineer's background and the project's conventions.
-
-## Current Task
-
-Answer questions about this project in a way that's tailored to the engineer's existing knowledge. Relate unfamiliar concepts to what they already know.
-
-## Context Sources
-
-Before answering any question, read these files (if they exist):
-
-1. `.claude/onboard-profile.local.md` — Engineer's background, skills, knowledge gaps
-2. `CLAUDE.md` — Project conventions and instructions
-3. `README.md` — Project overview
-
-Use the engineer's profile to personalize every answer.
-
-## Your Role
-
-1. **Answer Project Questions**: "How do I add a new endpoint?", "What's the testing pattern?"
-2. **Explain Conventions**: "Why do we use this import style?", "What's the file naming rule?"
-3. **Navigate the Codebase**: "Where should this file go?", "Show me an example of X"
-4. **Bridge Knowledge Gaps**: Relate new concepts to the engineer's existing skills
-
-## Response Style
-
-### Always Do
-- Start from the engineer's frame of reference (check their profile)
-- Use analogies to technologies they already know
-- Point to specific files in this codebase as examples
-- Include file paths so they can navigate directly
-- Keep answers concise — they're trying to get work done, not read a textbook
-
-### Never Do
-- Explain things they already know (check profile)
-- Give generic answers that ignore project conventions
-- Dump entire file contents — show relevant snippets only
-- Assume knowledge they don't have
-
-## Personalization Examples
-
-**Engineer knows Django, project uses Next.js:**
-
-Question: "How do API routes work here?"
-
-Response:
-```
-API routes in Next.js are like Django views but organized by file path.
-
-Django:
-  # users/views.py
-  class UserListView(APIView):
-      def get(self, request): ...
-
-Next.js equivalent:
-  // app/api/users/route.ts
-  export async function GET(request: Request) { ... }
-
-In this project, API routes are at `app/api/`.
-See `app/api/auth/login/route.ts` for an example.
-```
-
-**Engineer knows React, project uses Django:**
-
-Question: "How does the ORM work?"
-
-Response:
-```
-Django ORM is like TanStack Query but server-side — it manages
-database queries instead of API calls.
-
-React/TanStack:
-  const { data } = useQuery({ queryKey: ['users'], queryFn: fetchUsers })
-
-Django equivalent:
-  users = _users_models.User.objects.filter(is_active=True)
-
-In this project, models are in each app's `models.py`.
-See `users/models.py` for the pattern.
-```
-
-**Engineer is senior, just new to the framework:**
-
-Keep it brief. Skip conceptual explanations, focus on syntax and patterns:
-```
-API routes go in `app/api/{resource}/route.ts`.
-Export named functions: GET, POST, PUT, DELETE.
-See `app/api/auth/login/route.ts` for the pattern used here.
-```
-
-## When Profile Doesn't Exist
-
-If `.claude/onboard-profile.local.md` doesn't exist:
-- Ask: "I don't have your onboarding profile. Want to run `/onboard` first, or should I just answer based on what I see in the project?"
-- If they want to skip: answer at a moderate detail level, no personalization
-
-## Handling "I Don't Know" Questions
-
-If the engineer asks something you can't answer from the codebase:
-1. Say what you do know from the code
-2. Suggest who to ask or where to look
-3. Don't make things up
-
-## Final Checklist
-
-Before every response, verify:
-- [ ] Checked engineer's profile for background context
-- [ ] Used analogies to their existing knowledge (if applicable)
-- [ ] Included specific file paths from this project
-- [ ] Kept the answer concise and actionable
-- [ ] Respected project conventions from CLAUDE.md

package/packs/onboard/commands/onboard.md

@@ -1,313 +0,0 @@
----
-name: onboard
-description: Interactive onboarding flow that assesses engineer skills, analyzes the project, and generates personalized guidance for getting productive fast
-argument-hint: '[--quick] [--task "description"]'
-allowed-tools: ["Read", "Write", "Glob", "Grep", "Bash", "AskUserQuestion"]
----
-
-# Engineer Onboarding
-
-Run a guided onboarding flow that personalizes project guidance based on the engineer's background and their first task.
-
----
-
-## Steps
-
-### 1. Parse Arguments
-
-Extract from user input:
-- **--quick**: Skip skill assessment, assume mid-level generalist (optional)
-- **--task**: Pre-specify first task to skip task question (optional)
-
-### 2. Introduction
-
-Briefly explain what will happen:
-
-```
-Welcome! I'll get you up to speed on this project in a few minutes.
-
-Here's how this works:
-1. A few questions about your background (so I don't over-explain things you know)
-2. I'll analyze the project automatically
-3. You'll get personalized guidance + a cheat sheet
-
-Let's start.
-```
-
-### 3. Engineer Assessment (skip if --quick)
-
-Ask these core questions using AskUserQuestion:
-
-**Question 1 - Primary Stack:**
-"What's your primary language/framework and roughly how long have you been using it?"
-
-**Question 2 - Other Skills:**
-"What other languages or frameworks are you comfortable with?"
-
-**Question 3 - New Territory:**
-"Looking at this project, what feels completely new or unfamiliar to you?"
-
-**Adaptive Follow-ups (only ask if gaps detected):**
-
-After analyzing the answers, ask follow-ups ONLY for detected gaps:
-
-- If the project uses frontend tech and engineer is backend-only:
-  "Any experience with component-based UI frameworks (React, Vue, etc.)?"
-
-- If the project uses backend tech and engineer is frontend-only:
-  "Have you worked with ORMs, REST APIs, or database design?"
-
-- If the project has tests and engineer didn't mention testing:
-  "How comfortable are you with writing tests / TDD?"
-
-- If the project uses TypeScript and engineer only mentioned JavaScript:
-  "How's your TypeScript experience — types, generics, strict mode?"
-
-Maximum 2 follow-up questions. Keep the assessment fast.
-
-### 4. Project Analysis (automatic)
-
-Analyze the project silently. Do NOT ask the engineer anything here.
-
-**4a. Detect Project Type:**
-
-```bash
-# Frontend
-[ -f "package.json" ] && grep -q '"next"' package.json && echo "nextjs"
-[ -f "package.json" ] && grep -q '"nuxt"' package.json && echo "nuxtjs"
-[ -f "package.json" ] && grep -q "@tanstack/react-router" package.json && echo "tanstack-router"
-[ -f "package.json" ] && grep -q '"hono"' package.json && echo "hono"
-
-# Backend
-[ -f "manage.py" ] && echo "django"
-[ -f "package.json" ] && grep -q "@nestjs/core" package.json && echo "nestjs"
-
-# Mobile
-[ -f "pubspec.yaml" ] && echo "flutter"
-
-# Auth
-[ -f "package.json" ] && grep -q '"better-auth"' package.json && echo "better-auth"
-```
-
-**4b. Read Key Files:**
-
-Read these files if they exist (silently, don't dump contents to user):
-- `CLAUDE.md` — project conventions and instructions
-- `README.md` — project overview
-- `package.json` or `pyproject.toml` — dependencies and scripts
-- `docker-compose.yml` or `Dockerfile` — infrastructure setup
-- `.env.example` or `.env.template` — required environment variables
-
-**4c. Analyze Code Patterns:**
-
-Examine 3-5 actual source files to detect:
-- Import style (relative vs absolute, aliases, barrel exports)
-- File naming convention (kebab-case, camelCase, PascalCase)
-- Component/view patterns (class-based, functional, hooks)
-- Test location (co-located `__tests__/`, separate `tests/`)
-- State management approach
-- Error handling patterns
-
-**4d. Detect Installed Smicolon Plugins:**
-
-Check if the project uses any Smicolon marketplace plugins by looking for plugin-related patterns in code (import aliases like `_users_models`, BaseModel inheritance, etc.).
-
-### 5. Knowledge Gap Analysis (automatic)
-
-Cross-reference engineer's skills with project requirements:
-
-```
-Engineer Skills: [what they said in assessment]
-Project Stack: [what was detected in analysis]
-
-For each project technology:
-  - FAMILIAR: Engineer mentioned it → skip detailed explanation
-  - TRANSFERABLE: Engineer knows something similar → explain differences
-  - NEW: Engineer has no related experience → explain from scratch
-
-Prioritize by criticality:
-  - HIGH: Core to daily work (e.g., the main framework)
-  - MEDIUM: Used regularly but not the core (e.g., testing framework)
-  - LOW: Used occasionally (e.g., deployment tools)
-```
-
-**Personalization Strategy:**
-
-Map new concepts to the engineer's existing knowledge. Examples:
-
-| Engineer Knows | Project Uses | Analogy |
-|---------------|-------------|---------|
-| Django views | Next.js Server Components | "Like Django views but written in JSX" |
-| React state | Django ORM | "Like useState but for database records" |
-| REST APIs | GraphQL | "Same data, different query language" |
-| unittest | pytest | "Same idea, better syntax and fixtures" |
-| JavaScript | TypeScript | "Your JS + type annotations" |
-
-### 6. Task Context (skip if --task provided)
-
-Ask using AskUserQuestion:
-
-**Question:** "What will you be working on first? (Feature, bug fix, or task description)"
-
-**Follow-up** (only if helpful): "Is there an existing feature in the codebase similar to what you need to build?"
-
-### 7. Generate Personalized Briefing
-
-Present the onboarding briefing directly in conversation. Structure:
-
-```markdown
-## Project Overview
-[1-2 sentences about what this project is, from README/CLAUDE.md]
-
-## Tech Stack
-[List detected technologies, mark which ones are NEW for this engineer]
-
-## What You Need to Know
-[Personalized explanations for knowledge gaps, using analogies to their background]
-[Only explain what they DON'T already know]
-
-## Project Conventions
-[Key conventions from CLAUDE.md, focused on ones relevant to their task]
-[Import patterns, file structure, naming conventions]
-
-## Your First Task: [task name]
-[Step-by-step breakdown:]
-1. Start by reading: [2-3 key files to understand the pattern]
-2. Create/modify: [what files they'll work on]
-3. Follow this pattern: [code example from the codebase]
-4. Test with: [how to run tests]
-
-## Getting Started
-[Setup commands: install deps, run dev server, run tests]
-[Environment variables needed]
-```
-
-### 8. Generate Artifacts
-
-Save three files to `.claude/` (local only, gitignored):
-
-**8a. Engineer Profile** — `.claude/onboard-profile.local.md`
-
-```markdown
----
-engineer_name: "{{NAME_OR_ANONYMOUS}}"
-onboarded_at: "{{ISO_TIMESTAMP}}"
-experience_level: "{{junior|mid|senior}}"
----
-
-# Onboarding Profile
-
-## Background
-- **Primary Stack**: {{PRIMARY_SKILLS}}
-- **Also Knows**: {{SECONDARY_SKILLS}}
-- **New To**: {{NEW_SKILLS}}
-
-## Project: {{PROJECT_NAME}}
-- **Tech Stack**: {{DETECTED_STACK}}
-- **Architecture**: {{ARCHITECTURE_PATTERN}}
-
-## Knowledge Gaps
-{{For each gap:}}
-- [ ] {{TECHNOLOGY}} ({{HIGH|MEDIUM|LOW}} priority) — {{one-line explanation}}
-
-## Current Task
-{{TASK_DESCRIPTION}}
-
-## Key Files for This Task
-{{LIST_OF_FILES}}
-```
-
-**8b. Cheat Sheet** — `.claude/onboard-cheatsheet.local.md`
-
-```markdown
-# {{PROJECT_NAME}} Cheat Sheet
-
-## Quick Commands
-| Action | Command |
-|--------|---------|
-| Install deps | {{INSTALL_CMD}} |
-| Run dev server | {{DEV_CMD}} |
-| Run tests | {{TEST_CMD}} |
-| Lint | {{LINT_CMD}} |
-
-## Import Patterns
-{{DETECTED_IMPORT_STYLE_WITH_EXAMPLES}}
-
-## File Structure
-{{KEY_DIRECTORIES_AND_WHAT_GOES_WHERE}}
-
-## Where to Add Things
-| What | Where |
-|------|-------|
-| New API route | {{PATH}} |
-| New component | {{PATH}} |
-| New test | {{PATH}} |
-| New model/entity | {{PATH}} |
-
-## Conventions Quick Reference
-{{TOP_5_CONVENTIONS_FROM_CLAUDE_MD}}
-```
-
-**8c. Task Plan** — `.claude/onboard-task-plan.local.md`
-
-```markdown
-# Task Plan: {{TASK_NAME}}
-
-## Similar Existing Code
-{{REFERENCE_FILES_THAT_FOLLOW_SAME_PATTERN}}
-
-## Steps
-### 1. {{STEP_NAME}}
-- File: {{FILE_PATH}}
-- What to do: {{DESCRIPTION}}
-- Pattern to follow: {{REFERENCE_FILE}}
-
-### 2. {{STEP_NAME}}
-...
-
-## Testing
-- Run: {{TEST_COMMAND}}
-- Check: {{WHAT_TO_VERIFY}}
-
-## When Stuck
-- Ask `@onboard-guide` for project-specific questions
-- Reference `.claude/onboard-cheatsheet.local.md` for conventions
-```
-
-### 9. Wrap Up
-
-After generating everything:
-
-```
-Onboarding complete! Here's what I created:
-
-- .claude/onboard-profile.local.md — Your background + knowledge gaps
-- .claude/onboard-cheatsheet.local.md — Quick reference for conventions
-- .claude/onboard-task-plan.local.md — Step-by-step plan for your task
-
-Next steps:
-1. Skim the cheat sheet
-2. Read the 2-3 files mentioned in your task plan
-3. Start implementing — use @onboard-guide for questions as you go
-```
-
----
-
-## Quick Mode (--quick)
-
-When `--quick` flag is present:
-1. Skip Step 3 (engineer assessment)
-2. Assume mid-level generalist developer
-3. Explain everything at moderate detail
-4. Still do full project analysis and task planning
-5. Still generate all artifacts
-
----
-
-## Error Handling
-
-- **No CLAUDE.md**: Fall back to README.md and code analysis. Note that conventions may be incomplete.
-- **No README.md**: Extract project purpose from package.json description and code structure.
-- **Monorepo detected**: Ask which package/app the engineer will work in, then scope analysis to that directory.
-- **No clear tech stack**: Ask the engineer what the project uses.
-- **Engineer says "I know everything"**: Skip explanations, focus on conventions and task planning only.

package/packs/onboard/skills/onboard-context-provider/SKILL.md

@@ -1,98 +0,0 @@
----
-name: onboard-context-provider
-description: Provides personalized assistance based on engineer's onboarding profile. Activates when engineer asks "how do I", "where should I", "what's the pattern for", shows confusion about conventions, or writes code that doesn't match project patterns. Reads .claude/onboard-profile.local.md for context.
----
-
-# Onboard Context Provider
-
-Provides personalized explanations and assistance based on the engineer's background from their onboarding profile.
-
-## Activation Triggers
-
-This skill activates when:
-- Engineer asks "how do I..." or "where do I put..." questions
-- Engineer asks about project conventions or patterns
-- Code written doesn't match project conventions (imports, naming, structure)
-- Engineer seems confused about a technology in their knowledge gaps list
-
-## Profile Location
-
-```
-.claude/onboard-profile.local.md
-```
-
-If this file doesn't exist, this skill does nothing. The engineer needs to run `/onboard` first.
-
-## Behavior
-
-### 1. Read Engineer Profile
-
-Check `.claude/onboard-profile.local.md` for:
-- **Primary Stack**: What they know well
-- **New To**: What's unfamiliar
-- **Knowledge Gaps**: Specific gaps with priority levels
-- **Current Task**: What they're working on
-
-### 2. Personalize Response
-
-Based on the profile, adjust explanations:
-
-**If the concept is in their knowledge gaps (NEW):**
-- Explain using analogies to their primary stack
-- Show a side-by-side comparison with what they know
-- Point to an example file in the codebase
-
-**If the concept is related to something they know (TRANSFERABLE):**
-- Briefly note the difference, skip the basics
-- Focus on what's different, not what's the same
-
-**If they already know it (FAMILIAR):**
-- Don't explain the concept at all
-- Just show the project-specific convention
-
-### 3. Always Include
-
-- Specific file paths from this project as examples
-- The project convention (from CLAUDE.md) for whatever they're doing
-- A concrete next action they can take
-
-## Personalization Strategies
-
-### Backend Engineer → Frontend Project
-
-| Concept | Explain As |
-|---------|-----------|
-| Components | "Like views that return HTML directly" |
-| State (useState) | "Like a variable that re-renders the page when changed" |
-| Props | "Like function arguments for components" |
-| useEffect | "Like Django signals — side effects triggered by changes" |
-| Client vs Server Components | "Server = Django view, Client = JavaScript in template" |
-
-### Frontend Engineer → Backend Project
-
-| Concept | Explain As |
-|---------|-----------|
-| ORM Models | "Like TypeScript interfaces that map to database tables" |
-| Migrations | "Like schema changes — versioned database updates" |
-| Serializers | "Like Zod schemas for API input/output validation" |
-| Views/Controllers | "Like API route handlers" |
-| Middleware | "Same concept — runs before your handler" |
-
-### Senior → New Framework
-
-- Skip conceptual explanations entirely
-- Focus on: syntax, file locations, project conventions
-- Example: "API routes at `app/api/*/route.ts`, export GET/POST/etc."
-
-### Junior → Any Framework
-
-- Include "why" not just "how"
-- Provide more context about patterns
-- Suggest reading material when appropriate
-
-## What NOT to Do
-
-- Don't activate if no profile exists (engineer hasn't onboarded)
-- Don't over-explain things the engineer already knows
-- Don't provide generic advice — always reference this specific project
-- Don't interrupt the engineer's flow with unsolicited lectures

package/packs/tanstack-router/CHANGELOG.md

@@ -1,30 +0,0 @@
-# Changelog
-
-All notable changes to the smi-tanstack-router plugin will be documented in this file.
-
-## [Unreleased]
-
-### Changed
-- Renamed from `smi-tanstack-router` to `tanstack-router` as part of ai-kit migration
-- Moved from `plugins/smi-tanstack-router/` to `packs/tanstack-router/`
-
-## [0.1.0] - 2025-01-02
-
-### Added
-- Initial release (experimental)
-- 3 agents: tanstack-architect, tanstack-builder, tanstack-tester
-- 4 commands: route-create, query-create, form-create, table-create
-- 11 skills for TanStack ecosystem:
-  - `router-patterns` - File-based routing
-  - `query-patterns` - Data fetching with factory keys
-  - `form-patterns` - TanStack Form + Zod
-  - `table-patterns` - Headless tables
-  - `virtual-patterns` - List virtualization
-  - `store-patterns` - State management (alpha)
-  - `db-patterns` - Client-first database (beta)
-  - `ai-patterns` - AI/LLM integration (alpha)
-  - `pacer-patterns` - Rate limiting (beta)
-  - `devtools-patterns` - Developer tools
-  - `tanstack-conventions` - Project conventions
-- Bun as package manager and runtime
-- Feature-based project structure

package/packs/tanstack-router/README.md

@@ -1,113 +0,0 @@
-# tanstack-router
-
-TanStack SPA development with the full ecosystem: Router, Query, Form, Table, Virtual, and experimental libraries.
-
-## Overview
-
-This plugin provides comprehensive support for building React SPAs with the TanStack ecosystem, using Bun as the runtime and following feature-based architecture with `@/` import aliases.
-
-## Installation
-
-```bash
-/plugin install tanstack-router
-```
-
-## Features
-
-### Core Libraries
-- **TanStack Router** - Type-safe file-based routing
-- **TanStack Query** - Server state management with factory key patterns
-- **TanStack Form** - Type-safe form handling
-- **TanStack Table** - Headless table/datagrid
-- **TanStack Virtual** - List virtualization
-
-### Experimental Libraries (Alpha/Beta)
-- **TanStack Store** - Framework-agnostic state
-- **TanStack DB** - Client-first reactive store
-- **TanStack AI** - Unified AI SDK
-- **TanStack Pacer** - Rate limiting, debouncing, throttling
-- **TanStack Devtools** - Unified debugging tools
-
-## Agents
-
-| Agent | Purpose |
-|-------|---------|
-| `tanstack-architect` | Design TanStack application architecture |
-| `tanstack-builder` | Implement features with TanStack patterns |
-| `tanstack-tester` | Write tests for TanStack applications |
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `/route-create` | Create a new file-based route |
-| `/query-create` | Create query with factory key pattern |
-| `/form-create` | Create type-safe form with validation |
-| `/table-create` | Create headless table component |
-
-## Conventions
-
-### Folder Structure (Feature-Based)
-```
-src/
-├── features/
-│   ├── posts/
-│   │   ├── components/
-│   │   ├── hooks/
-│   │   ├── queries/
-│   │   └── types.ts
-│   └── users/
-├── routes/
-│   ├── __root.tsx
-│   ├── index.tsx
-│   └── posts/
-│       ├── index.tsx
-│       └── $postId.tsx
-├── lib/
-│   ├── query-client.ts
-│   └── query-keys.ts
-└── components/
-    └── ui/
-```
-
-### Import Alias
-```typescript
-import { PostList } from '@/features/posts/components'
-import { queryKeys } from '@/lib/query-keys'
-```
-
-### Query Key Factory Pattern
-```typescript
-export const queryKeys = {
-  posts: {
-    all: () => ['posts'] as const,
-    lists: () => [...queryKeys.posts.all(), 'list'] as const,
-    list: (filters: Filters) => [...queryKeys.posts.lists(), filters] as const,
-    details: () => [...queryKeys.posts.all(), 'detail'] as const,
-    detail: (id: string) => [...queryKeys.posts.details(), id] as const,
-  }
-}
-```
-
-### Data Fetching (Hybrid Approach)
-- **Loaders**: Prefetch data in route loaders
-- **Queries**: Hydrate and manage in components
-
-```typescript
-// Route loader prefetches
-export const Route = createFileRoute('/posts/$postId')({
-  loader: ({ context, params }) =>
-    context.queryClient.ensureQueryData(postQueryOptions(params.postId)),
-})
-
-// Component hydrates
-function PostPage() {
-  const { postId } = Route.useParams()
-  const { data } = useSuspenseQuery(postQueryOptions(postId))
-}
-```
-
-## Runtime
-
-- **Bun** - Package manager and runtime
-- Commands use `bun` instead of `npm`/`yarn`