@slycode/slycode 0.1.0 → 0.1.2

package/templates/tutorial-project/.claude/skills/design/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: design
+version: 1.1.1
+updated: 2026-02-22
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, SlashCommand
+argument-hint: "design topic (e.g., Session management system)"
+description: "Start iterative requirements gathering for a design document"
+---
+
+# Design Discovery
+
+Start an iterative requirements-gathering session for a new design. Creates a lightweight document in `documentation/designs/` focused on exploring the problem space, not implementation details.
+
+## Mode: Requirements Gathering
+
+This command sets you into **requirements mode**:
+- Ask clarifying questions rather than making assumptions
+- Explore alternatives and trade-offs with the user
+- Focus on WHAT and WHY, not HOW
+- Keep the document evolving as understanding grows
+- No implementation details, no code, no file lists
+
+## Instructions
+
+1. **Create initial design doc** with the problem statement and open questions
+2. **Enter conversational mode** - engage the user to flesh out requirements
+3. **Update the doc iteratively** as decisions are made
+4. **Flag when design is ready** to become a feature spec
+
+## Workflow
+
+1. **Get current date** using bash
+2. **Create design document** in `documentation/designs/`
+3. **Name the file** as `{descriptive_name}.md` (snake_case, no date prefix)
+4. **Link design to card** - Run this command to attach the design doc to the kanban card:
+   ```bash
+   node scripts/kanban.js update <card-id> --design-ref "documentation/designs/{name}.md"
+   ```
+   **IMPORTANT:** This is a separate CLI command you must execute. Do NOT add the path to the card's description field. The `--design-ref` flag sets a dedicated field on the card that links to this design document.
+5. **Engage user** with initial clarifying questions
+6. **Update doc** as requirements solidify
+
+## Document Format
+
+```md
+# Design: {topic}
+
+**Status:** Discovery
+**Created:** YYYY-MM-DD
+**Last Updated:** YYYY-MM-DD
+
+## Problem Statement
+
+<What problem are we solving? Why does it matter? Who is affected?>
+
+## Goals
+
+<What must this solution achieve?>
+1. <goal>
+2. <goal>
+
+## Non-Goals
+
+<What is explicitly out of scope?>
+- <non-goal>
+
+## Context
+
+<Background info, constraints, related systems>
+
+## Approach Options
+
+### Option A: <name>
+<Description, pros, cons>
+
+### Option B: <name>
+<Description, pros, cons>
+
+## Decisions
+
+<Record decisions as they're made>
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| <topic> | <choice> | <why> |
+
+## Open Questions
+
+<Questions that need answers before implementation>
+- [ ] <question>
+- [ ] <question>
+
+## Related Areas
+
+<Context-priming areas relevant to this design>
+- <area>: <why relevant>
+
+## Notes
+
+<Captured thoughts, references, examples>
+```
+
+## Conversational Guidelines
+
+When in design mode:
+
+1. **Start with questions** - Don't assume you understand the problem
+   - "What problem are you trying to solve?"
+   - "Who will use this? In what context?"
+   - "What constraints should I know about?"
+
+2. **Present options** - When there are multiple approaches
+   - "I see two main ways to approach this..."
+   - "Option A trades X for Y, Option B does the opposite..."
+
+3. **Capture decisions** - When the user makes a choice
+   - Update the Decisions table with rationale
+   - Remove resolved items from Open Questions
+
+4. **Check readiness** - When requirements feel complete
+   - "I think we've covered the requirements. Ready to create a feature spec?"
+   - If yes: "Run `/feature {design name}` to create the implementation plan"
+
+## Transition to Feature Spec
+
+When the design is ready for implementation:
+1. Update Status to "Ready"
+2. Inform user to run `/feature` referencing this design
+3. The feature spec will link back via `design_ref`
+
+## Reporting
+
+After creating the initial document:
+- File created: `documentation/designs/{name}.md`
+- Card linked: (if in card session) design_ref updated
+- Status: Discovery
+- Mode: Requirements gathering active
+- First question: Start exploring the problem space
+
+## Design Topic
+$ARGUMENTS

package/templates/tutorial-project/.claude/skills/feature/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: feature
+version: 1.1.1
+updated: 2026-02-22
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, SlashCommand
+argument-hint: "feature description (e.g., Add bulk message operations)"
+description: "Create a numbered feature specification following project standards"
+---
+
+# Feature Planning
+
+Create a new feature specification in `documentation/features/` with the next available number. The plan will follow a comprehensive feature planning format.
+
+## Instructions
+
+1. **Scan for next feature number** - Check existing features to determine next number
+2. **Check project context** - If you need more context about specific areas:
+   - Review relevant project documentation (if available: `/prime <area>` or CLAUDE.md)
+   - Identify key architectural areas the feature touches
+3. **Research the codebase** to understand existing patterns and architecture
+4. **Create comprehensive plan** following the format below
+5. **Name the file** as `{number}_{feature_name}.md` (e.g., `038_bulk_message_operations.md`)
+
+## Workflow
+
+1. **Determine next feature number**:
+   - List files in `documentation/features/`
+   - Find highest numbered feature
+   - Next number = highest + 1
+2. **Analyze feature requirements** from description
+3. **Check if sufficient context** is loaded for the feature
+4. **Create the plan** in `documentation/features/` directory
+5. **Link feature to card** - Run this command to attach the feature spec to the kanban card:
+   ```bash
+   node scripts/kanban.js update <card-id> --feature-ref "documentation/features/{number}_{name}.md"
+   ```
+   **IMPORTANT:** This is a separate CLI command you must execute. Do NOT add the path to the card's description field. The `--feature-ref` flag sets a dedicated field on the card that links to this feature spec.
+
+## Context Integration
+
+Before creating the plan:
+- Identify which project areas/modules the feature touches
+- Check if sufficient context exists (project docs, CLAUDE.md, architecture files)
+- If needed, suggest: "This feature involves {areas}. Consider reviewing {relevant docs} for better context."
+
+## Plan Format
+
+```md
+# Feature {number}: {feature name}
+
+**Status**: DRAFT
+**Created**: YYYY-MM-DD
+**Last Updated**: YYYY-MM-DD
+
+## Feature Description
+<describe the feature in detail, including its purpose and value to users>
+
+## User Story
+As a <type of user>
+I want to <action/goal>
+So that <benefit/value>
+
+## Problem Statement
+<clearly define the specific problem or opportunity this feature addresses>
+
+## Solution Statement
+<describe the proposed solution approach and how it solves the problem>
+
+## Context Areas
+<note which project areas/modules are relevant to this feature>
+- Required areas: [list areas like frontend, backend, api, database, etc.]
+- Additional context: [reference relevant documentation or architecture files]
+
+## Relevant Files
+Use these files to implement the feature:
+
+<find and list the files that are relevant to the feature describe why they are relevant in bullet points. Reference patterns from CLAUDE.md and project documentation.>
+
+### New Files
+<if any new files need to be created, list them here following project conventions>
+
+## Implementation Plan
+### Phase 1: Foundation
+<describe the foundational work needed before implementing the main feature>
+
+### Phase 2: Core Implementation
+<describe the main implementation work for the feature>
+
+### Phase 3: Integration
+<describe how the feature will integrate with existing functionality>
+
+## Step by Step Tasks
+IMPORTANT: Execute every step in order, top to bottom.
+
+<list step by step tasks as h3 headers plus bullet points. Reference project patterns from CLAUDE.md and documentation.>
+
+### Task 1: <descriptive name>
+- <specific actions following project conventions>
+- <file modifications>
+
+### Task 2: <descriptive name>
+- <specific actions>
+- <file modifications>
+
+### Task N: Run Full Validation
+- Execute all validation commands
+- Verify feature works end-to-end
+- Check for regressions
+
+## Testing Strategy
+### Unit Tests
+<describe unit tests needed following project test standards>
+
+### Integration Tests
+<describe integration tests needed>
+
+### E2E Tests
+<if applicable, describe end-to-end tests>
+
+### Edge Cases
+<list edge cases that need to be tested>
+
+## Acceptance Criteria
+<list specific, measurable criteria that must be met for the feature to be considered complete>
+- [ ] Feature works as described
+- [ ] All tests pass
+- [ ] No regressions introduced
+- [ ] Documentation updated
+- [ ] <specific criteria for this feature>
+
+## Validation Commands
+Execute every command to validate the feature works correctly with zero regressions.
+
+<list project-specific validation commands - examples:>
+- Run test suite (e.g., `pytest`, `npm test`, `make test`)
+- Run linters (e.g., `npm run lint`, `flake8`, `eslint`)
+- Run type checking (e.g., `mypy`, `tsc --noEmit`)
+- Build the project (e.g., `npm run build`, `make build`)
+- Manual testing steps
+- <specific tests for this feature>
+
+## Future Considerations
+<optional: future enhancements or related features to consider>
+
+## Notes
+<optionally list any additional notes, dependencies, or context that are relevant to the feature>
+```
+
+## Reporting
+
+After creating the plan, report:
+- File created: `documentation/features/{number}_{feature_name}.md`
+- Card linked: feature_ref updated via CLI command
+- Feature number: {number}
+- Status: DRAFT
+- Next step: Run `/implement` with the plan path when ready
+
+## Feature
+$ARGUMENTS

package/templates/tutorial-project/.claude/skills/implement/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: implement
+version: 1.1.1
+updated: 2026-02-22
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, TodoWrite, Task
+argument-hint: "path to chore or feature plan"
+description: "Execute a chore or feature plan and handle document lifecycle"
+---
+
+# Implement Plan
+
+Execute the specified chore or feature plan, then handle the appropriate document lifecycle. This command follows a pattern where completed chores move to a completed directory while features remain in place with updated status.
+
+## Instructions
+
+1. **Detect document type** from the file path:
+   - If path contains `/chores/`: This is a chore
+   - If path contains `/features/`: This is a feature
+2. **Read and execute** the plan thoroughly
+3. **Handle lifecycle** based on document type (see lifecycle patterns below)
+4. **Update indexes** (if project maintains index files) and report results
+
+**Note**: The lifecycle management pattern below is a suggested approach. Adapt to your project's documentation structure and workflow.
+
+## Workflow
+
+### Phase 1: Plan Analysis
+- Read the plan document
+- Identify all tasks to execute
+- Note validation commands
+- Check completion criteria
+
+### Phase 2: Implementation
+- Execute tasks in order
+- Run validation commands
+- Verify completion criteria met
+- Track all changes made
+
+### Phase 3: Document Lifecycle
+
+**For Chores** (suggested pattern):
+1. Move file from `documentation/chores/` to `documentation/chores/completed/`
+2. Update status in file from ACTIVE to COMPLETED
+3. Add completion date
+4. Update project indexes (if maintained):
+   - Remove from active chores list
+   - Add to completed chores list
+
+**For Features** (suggested pattern):
+1. Keep file in `documentation/features/` (features typically remain in place)
+2. Update status from DRAFT to FINAL (or IMPLEMENTED/COMPLETE as per project convention)
+3. Update last modified date
+4. Update feature index/README (if project maintains one)
+
+**Note**: Adjust these lifecycle steps to match your project's documentation conventions.
+
+### Phase 3b: Kanban Card Update
+
+If `scripts/kanban.js` exists, move the associated card to testing:
+
+1. Check if kanban CLI exists: `test -f scripts/kanban.js`
+2. If the plan references a card ID (in frontmatter or content), or if running in a card session:
+   - Move card to testing: `node scripts/kanban.js move <card-id> testing`
+3. This signals the work is ready for testing/review
+
+### Phase 4: Reporting
+
+Generate comprehensive report including:
+- Summary of work completed
+- Files modified (with git diff --stat)
+- Tests run and results
+- Document status changes
+- Index updates performed
+
+## Plan
+$ARGUMENTS
+
+## Lifecycle Actions
+
+Based on the document type detected, perform appropriate actions:
+
+### Chore Completion (Example)
+```bash
+# Move to completed directory (if using this pattern)
+mv documentation/chores/{file} documentation/chores/completed/
+
+# Update status in document (ACTIVE → COMPLETED)
+# Add completion date
+# Update project indexes (if applicable)
+```
+
+### Feature Completion (Example)
+```bash
+# Update status in document (DRAFT → FINAL/IMPLEMENTED)
+# Update last modified date
+# Update feature index (if project maintains one)
+```
+
+**Adapt these actions to your project's structure and conventions.**
+
+## Report Format
+
+Provide a comprehensive report following this template:
+
+```
+✅ Implementation Complete
+
+**Document**: {path}
+**Type**: {Chore|Feature}
+**Status**: {COMPLETED|FINAL|IMPLEMENTED}
+
+**Work Summary**:
+- {task 1 completed}
+- {task 2 completed}
+- {validation passed}
+
+**Files Changed**:
+{git diff --stat output or summary of changes}
+
+**Lifecycle Actions**:
+- {Document moved to completed/ | Status updated to FINAL}
+- {Index updates performed (if applicable)}
+
+**Validation Results**:
+- {Tests run and results}
+- {Build/lint status}
+
+**Next Steps**:
+- {Any follow-up actions or recommendations}
+```
+
+Adapt the report format to include project-specific metrics or validation results.

package/templates/tutorial-project/.claude/skills/kanban/SKILL.md

@@ -0,0 +1,264 @@
+---
+name: kanban
+version: 1.2.1
+updated: 2026-02-22
+description: "Manage kanban cards via CLI with commands for search, create, update, move, problem tracking, cross-agent notes, and scheduled automations"
+---
+
+# Kanban CLI Skill
+
+Manage kanban cards via CLI: `node scripts/kanban.js <command>`
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `search` | Find cards by query, stage, type, area |
+| `show` | Display full card details (NOT `view`) |
+| `create` | Create a new card |
+| `update` | Modify card fields |
+| `move` | Move card between stages |
+| `archive` | Soft delete a card |
+| `checklist` | Manage checklist items |
+| `problem` | Track issues on cards |
+| `notes` | Manage cross-agent notes |
+| `automation` | Configure and manage scheduled automations |
+| `areas` | List available areas |
+
+## Quick Reference
+
+```bash
+# Always start with --help if unsure
+node scripts/kanban.js --help
+node scripts/kanban.js <command> --help
+
+# Search cards
+node scripts/kanban.js search "query"
+node scripts/kanban.js search --stage backlog
+node scripts/kanban.js search --type feature
+
+# Show card details (use 'show', NOT 'view')
+node scripts/kanban.js show card-123
+
+# Create card
+node scripts/kanban.js create --title "Add feature X" --type feature --priority medium
+
+# Update card
+node scripts/kanban.js update card-123 --title "New title" --areas "web-frontend,terminal-bridge"
+
+# Link documentation to card
+node scripts/kanban.js update card-123 --design-ref "documentation/designs/foo.md"
+node scripts/kanban.js update card-123 --feature-ref "documentation/features/bar.md"
+
+# Move card
+node scripts/kanban.js move card-123 design
+
+# Archive card
+node scripts/kanban.js archive card-123
+
+# Checklist management
+node scripts/kanban.js checklist card-123 list
+node scripts/kanban.js checklist card-123 add "Write tests"
+node scripts/kanban.js checklist card-123 toggle check-123
+
+# Problem tracking
+node scripts/kanban.js problem card-123 list
+node scripts/kanban.js problem card-123 add "Bug description" --severity major
+node scripts/kanban.js problem card-123 resolve prob-123
+node scripts/kanban.js problem card-123 promote prob-123 --type chore
+
+# Agent notes
+node scripts/kanban.js notes card-123 list
+node scripts/kanban.js notes card-123 add "Context for next agent" --agent "Claude"
+node scripts/kanban.js notes card-123 search "blocker"
+node scripts/kanban.js notes card-123 edit 2 "Updated note text"
+node scripts/kanban.js notes card-123 delete 3
+node scripts/kanban.js notes card-123 clear
+
+# List available areas
+node scripts/kanban.js areas
+```
+
+## Best Practices
+
+1. **Always `show` first**: Before any action, run `show <card-id>` to see current state including existing problems
+2. **Check existing problems**: The card may already have problems logged - review before adding duplicates
+3. **Confirm with user**: When making significant changes, show the user what you plan to do
+4. **Use areas**: When creating/updating cards, set appropriate areas for context-priming
+5. **Track progress**: Use checklists for multi-step work items
+6. **Document problems**: When issues are found during testing, add them with `problem <card-id> add "description"`
+
+## Cross-Agent Notes
+
+Agent notes are a shared scratchpad on each card for passing context between agents and sessions.
+
+**When to use notes:**
+- Before starting work: `notes <card-id> list` — read what previous agents left
+- After completing a session: leave context about decisions, progress, or blockers
+- When hitting a blocker: document the issue so the next agent knows
+
+**Always identify yourself with `--agent`:**
+- Claude: `--agent "Claude"`
+- Codex: `--agent "Codex"`
+- Gemini: `--agent "Gemini"`
+- Notes added from the web UI are automatically tagged as `User`
+
+**Limits:** Max 30 notes per card, max 3000 characters per note.
+
+```bash
+# Read notes before starting
+node scripts/kanban.js notes card-123 list
+
+# Leave context after your session
+node scripts/kanban.js notes card-123 add "Completed API routes, tests passing. Frontend still needs the Notes tab wired up." --agent "Claude"
+
+# Flag a blocker
+node scripts/kanban.js notes card-123 add "Build fails on node 18 — needs --experimental flag for crypto" --agent "Codex"
+```
+
+## Integration with Onboard Action
+
+When using the Onboard action on a backlog card:
+1. Analyze and refine the card details through conversation
+2. Once the user confirms the refined version, use the CLI to apply changes:
+   ```bash
+   node scripts/kanban.js update <card-id> \
+     --title "Refined title" \
+     --description "Structured description" \
+     --areas "area1,area2" \
+     --priority high
+   ```
+
+## Linking Documentation
+
+Cards support dedicated reference fields for documentation:
+
+| Field | Flag | Purpose |
+|-------|------|---------|
+| Design Doc | `--design-ref` | Link to design document |
+| Feature Spec | `--feature-ref` | Link to feature specification |
+| Test Doc | `--test-ref` | Link to test documentation |
+
+```bash
+# Link design doc when moving to design stage
+node scripts/kanban.js update card-123 --design-ref "documentation/designs/my-feature.md"
+
+# Link feature spec when feature is fully specified
+node scripts/kanban.js update card-123 --feature-ref "documentation/features/001_my_feature.md"
+
+# Link test doc when test plan exists
+node scripts/kanban.js update card-123 --test-ref "documentation/tests/my-feature-tests.md"
+```
+
+These appear as dedicated fields on the card (not in description).
+
+## Workflow Examples
+
+### Refining a backlog item
+```bash
+# 1. View current state
+node scripts/kanban.js show card-123
+
+# 2. Update with refined details
+node scripts/kanban.js update card-123 \
+  --title "Implement user authentication with OAuth" \
+  --description "Add Google and GitHub OAuth providers..." \
+  --areas "backend,auth" \
+  --priority high
+
+# 3. Move to design when ready
+node scripts/kanban.js move card-123 design
+```
+
+### Creating a new task from user request
+```bash
+# User says: "I need to fix the login button being too small"
+node scripts/kanban.js create \
+  --title "Fix login button size" \
+  --type bug \
+  --priority medium \
+  --areas "web-frontend"
+```
+
+### Tracking testing progress
+```bash
+# Add checklist items
+node scripts/kanban.js checklist card-123 add "Unit tests pass"
+node scripts/kanban.js checklist card-123 add "Integration tests pass"
+node scripts/kanban.js checklist card-123 add "Manual testing complete"
+
+# Mark as done
+node scripts/kanban.js checklist card-123 toggle check-xxx
+
+# If issues found
+node scripts/kanban.js problem card-123 add "Login fails after timeout" --severity major
+```
+
+### Promoting problems to backlog
+When a problem is too big for a quick fix and needs its own design/implementation cycle:
+```bash
+# Review problems
+node scripts/kanban.js problem card-123 list
+
+# Promote a problem to a new backlog card
+node scripts/kanban.js problem card-123 promote prob-xxx --type chore
+
+# The original problem is marked resolved, new card created in backlog
+# Card inherits areas from source card, references original in description
+```
+
+## Scheduled Automations
+
+Cards can be toggled into automation mode — a scheduled task that fires a prompt into a terminal session at a specified time. One card = one automation.
+
+```bash
+# Create an automation card directly
+node scripts/kanban.js create --title "Nightly test run" --type chore --automation
+
+# Toggle existing card to automation mode
+node scripts/kanban.js update card-123 --automation true
+node scripts/kanban.js update card-123 --automation false
+
+# Configure automation (partial updates — only specified fields change)
+node scripts/kanban.js automation card-123 configure --schedule "0 6 * * *" --prompt "Run all tests" --provider claude
+node scripts/kanban.js automation card-123 configure --schedule "0 9 * * 1"    # just the schedule
+node scripts/kanban.js automation card-123 configure --prompt "New prompt"      # just the prompt
+node scripts/kanban.js automation card-123 configure --fresh-session true
+node scripts/kanban.js automation card-123 configure --report-messaging true
+
+# Enable / disable
+node scripts/kanban.js automation card-123 enable
+node scripts/kanban.js automation card-123 disable
+
+# Manual trigger (calls bridge API directly)
+node scripts/kanban.js automation card-123 run
+
+# View automation status
+node scripts/kanban.js automation card-123 status
+
+# List all automation cards
+node scripts/kanban.js automation list
+node scripts/kanban.js automation list --tag "deploy"
+```
+
+**Key concepts:**
+- Automation cards live on a dedicated Automations screen (not in kanban lanes)
+- The automation system is a "session starter" — it injects a prompt and confirms activity, nothing more
+- Schedule uses cron expressions (recurring) or ISO datetime (one-shot)
+- One-shot automations auto-disable after firing, config preserved
+- "Report via messaging" toggle appends instructions for the agent to send results
+
+## Error Handling
+
+The CLI provides clear error messages:
+- `Card 'xxx' not found` - Check the card ID
+- `Invalid stage` - Use: backlog, design, implementation, testing, done
+- `Invalid type` - Use: feature, chore, bug
+- `Invalid priority` - Use: low, medium, high, critical
+
+## Notes
+
+- The CLI modifies `documentation/kanban.json` directly
+- Changes are visible in the web UI on refresh
+- Archived cards are hidden by default (use `--include-archived` to see them)
+- All timestamps are in ISO format