claudekit-cli 1.0.0

package/.claude/commands/plan/two.md

@@ -0,0 +1,13 @@
+---
+description: Research & create an implementation plan with 2 approaches
+---
+
+Use the `planner` subagent to plan for this task:
+<task>
+ $ARGUMENTS
+</task>
+
+**Output:**
+Provide at least 2 implementation approaches with clear trade-offs, and explain the pros and cons of each approach, and provide a recommended approach.
+
+**IMPORTANT**: **Do not** start implementing.

package/.claude/commands/plan.md

@@ -0,0 +1,10 @@
+---
+description: Research, analyze, and create an implementation plan
+---
+
+Use the `planner` subagent to plan for this task:
+<task>
+ $ARGUMENTS
+</task>
+
+**IMPORTANT**: **Do not** start implementing.

package/.claude/commands/scout.md

@@ -0,0 +1,29 @@
+---
+description: Scout given directories to respond to the user's requests
+argument-hint: [user-prompt] [scale]
+---
+
+## Purpose
+
+Search the codebase for files needed to complete the task using a fast, token efficient agent.
+
+## User's requests & target directories
+<user_requests>$ARGUMENTS</user_requests>
+
+## Variables
+
+USER_PROMPT: $1
+SCALE: $2 (defaults to 3)
+RELEVANT_FILE_OUTPUT_DIR: `plans/scouts/`
+
+## Workflow:
+- Write a prompt for 'SCALE' number of agents to the Task tool that will immediately call the Bash tool to run these commands to kick off your agents to conduct the search:
+  - `gemini -p "[prompt]" --model gemini-2.5-flash-preview-09-2025`
+  - `opencode run "[prompt]" --model opencode/grok-code` (if count > 3)
+
+**How to prompt the agents:**
+- IMPORTANT: Kick these agents off in parallel using the Task tool, analyze and divide folders for each agent to scout intelligently and quickly.
+- IMPORTANT: These agents are calling OTHER agentic coding tools to search the codebase. DO NOT call any search tools yourself.
+- IMPORTANT: That means with the Task tool, you'll immediately call the Bash tool to run the respective agentic coding tool (gemini, opencode, claude, etc.)
+- IMPORTANT: Instruct the agents to quickly search the codebase for files needed to complete the task. This isn't about a full blown search, just a quick search to find the files needed to complete the task.
+- Instruct the subagent to use a timeout of 3 minutes for each agent's bash call. Skip any agents that don't return within the timeout, don't restart them.

package/.claude/commands/test.md

@@ -0,0 +1,7 @@
+---
+description: Debugging technical issues and providing solutions.
+---
+
+Use the `tester` subagent to run tests locally and analyze the summary report.
+
+**IMPORTANT**: **Do not** start implementing.

package/.claude/commands/watzup.md

@@ -0,0 +1,8 @@
+---
+description: Review recent changes and wrap up the work
+---
+Review my current branch and the most recent commits. 
+Provide a detailed summary of all changes, including what was modified, added, or removed. 
+Analyze the overall impact and quality of the changes.
+
+**IMPORTANT**: **Do not** start implementing.

package/.claude/hooks/telegram_notify.sh

@@ -0,0 +1,136 @@
+#!/bin/bash
+
+# Telegram Notification Hook for Claude Code (Project-Specific)
+# This hook sends a notification to Telegram when Claude finishes a task
+
+set -euo pipefail
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract relevant information from the hook input
+HOOK_TYPE=$(echo "$INPUT" | jq -r '.hookType // "unknown"')
+PROJECT_DIR=$(echo "$INPUT" | jq -r '.projectDir // ""')
+TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+SESSION_ID=$(echo "$INPUT" | jq -r '.sessionId // ""')
+PROJECT_NAME=$(basename "$PROJECT_DIR")
+
+# Configuration - these will be set via environment variables
+TELEGRAM_BOT_TOKEN="${TELEGRAM_BOT_TOKEN:-}"
+TELEGRAM_CHAT_ID="${TELEGRAM_CHAT_ID:-}"
+
+# Validate required environment variables
+if [[ -z "$TELEGRAM_BOT_TOKEN" ]]; then
+    echo "Error: TELEGRAM_BOT_TOKEN environment variable not set" >&2
+    exit 1
+fi
+
+if [[ -z "$TELEGRAM_CHAT_ID" ]]; then
+    echo "Error: TELEGRAM_CHAT_ID environment variable not set" >&2
+    exit 1
+fi
+
+# Function to send Telegram message
+send_telegram_message() {
+    local message="$1"
+    local url="https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage"
+    
+    # Escape special characters for JSON
+    local escaped_message=$(echo "$message" | jq -Rs .)
+    
+    local payload=$(cat <<EOF
+{
+    "chat_id": "${TELEGRAM_CHAT_ID}",
+    "text": ${escaped_message},
+    "parse_mode": "Markdown",
+    "disable_web_page_preview": true
+}
+EOF
+)
+    
+    curl -s -X POST \
+        -H "Content-Type: application/json" \
+        -d "$payload" \
+        "$url" > /dev/null
+}
+
+# Generate summary based on hook type
+case "$HOOK_TYPE" in
+    "Stop")
+        # Extract tool usage summary
+        TOOLS_USED=$(echo "$INPUT" | jq -r '.toolsUsed[]?.tool // empty' | sort | uniq -c | sort -nr)
+        FILES_MODIFIED=$(echo "$INPUT" | jq -r '.toolsUsed[]? | select(.tool == "Edit" or .tool == "Write" or .tool == "MultiEdit") | .parameters.file_path // empty' | sort | uniq)
+        
+        # Count operations
+        TOTAL_TOOLS=$(echo "$INPUT" | jq '.toolsUsed | length')
+        
+        # Build summary message
+        MESSAGE="🚀 *DevPocket Task Completed*
+        
+📅 *Time:* ${TIMESTAMP}
+📁 *Project:* ${PROJECT_NAME}
+🔧 *Total Operations:* ${TOTAL_TOOLS}
+🆔 *Session:* ${SESSION_ID:0:8}...
+
+*Tools Used:*"
+
+        if [[ -n "$TOOLS_USED" ]]; then
+            MESSAGE="${MESSAGE}
+\`\`\`
+${TOOLS_USED}
+\`\`\`"
+        else
+            MESSAGE="${MESSAGE}
+None"
+        fi
+
+        if [[ -n "$FILES_MODIFIED" ]]; then
+            MESSAGE="${MESSAGE}
+
+*Files Modified:*"
+            while IFS= read -r file; do
+                if [[ -n "$file" ]]; then
+                    # Show relative path from project root
+                    relative_file=$(echo "$file" | sed "s|^${PROJECT_DIR}/||")
+                    MESSAGE="${MESSAGE}
+• ${relative_file}"
+                fi
+            done <<< "$FILES_MODIFIED"
+        fi
+        
+        MESSAGE="${MESSAGE}
+
+📍 *Location:* \`${PROJECT_DIR}\`"
+        ;;
+        
+    "SubagentStop")
+        SUBAGENT_TYPE=$(echo "$INPUT" | jq -r '.subagentType // "unknown"')
+        MESSAGE="🤖 *DevPocket Subagent Completed*
+
+📅 *Time:* ${TIMESTAMP}
+📁 *Project:* ${PROJECT_NAME}
+🔧 *Agent Type:* ${SUBAGENT_TYPE}
+🆔 *Session:* ${SESSION_ID:0:8}...
+
+Specialized agent completed its task.
+
+📍 *Location:* \`${PROJECT_DIR}\`"
+        ;;
+        
+    *)
+        MESSAGE="📝 *DevPocket Code Event*
+
+📅 *Time:* ${TIMESTAMP}
+📁 *Project:* ${PROJECT_NAME}
+📋 *Event:* ${HOOK_TYPE}
+🆔 *Session:* ${SESSION_ID:0:8}...
+
+📍 *Location:* \`${PROJECT_DIR}\`"
+        ;;
+esac
+
+# Send the notification
+send_telegram_message "$MESSAGE"
+
+# Log the notification (optional)
+echo "Telegram notification sent for $HOOK_TYPE event in project $PROJECT_NAME" >&2

package/.claude/send-discord.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+
+# Usage: ./send-discord.sh 'Your message here'
+# Note: Remember to escape the string
+
+# Load environment variables from .env file
+if [[ -f .env ]]; then
+    echo "Loading .env file..."
+    set -a  # automatically export all variables
+    source .env
+    set +a  # turn off automatic export
+    echo "✅ Environment loaded, DISCORD_WEBHOOK_URL=$(echo ${DISCORD_WEBHOOK_URL:0:50}...)"
+else
+    echo "Warning: .env file not found"
+fi
+
+message="$1"
+    
+if [[ -z "$DISCORD_WEBHOOK_URL" ]]; then
+    echo "⚠️  Discord notification skipped: DISCORD_WEBHOOK_URL not set"
+    exit 1
+fi
+
+# Prepare message for Discord (Discord markdown supports \n)
+discord_message="$message"
+
+# Discord embeds for richer formatting
+payload=$(cat <<EOF
+{
+"embeds": [{
+    "title": "🤖 Claude Code Session Complete",
+    "description": "$discord_message",
+    "color": 5763719,
+    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)",
+    "footer": {
+        "text": "DevPocket API • $(basename "$(pwd)")"
+    },
+    "fields": [
+        {
+            "name": "⏰ Session Time",
+            "value": "$(date '+%H:%M:%S')",
+            "inline": true
+        },
+        {
+            "name": "📂 Project",
+            "value": "$(basename "$(pwd)")",
+            "inline": true
+        }
+    ]
+}]
+}
+EOF
+)
+
+curl -s -X POST "$DISCORD_WEBHOOK_URL" \
+    -H "Content-Type: application/json" \
+    -d "$payload" >/dev/null 2>&1
+
+if [[ $? -eq 0 ]]; then
+    echo "✅ Discord notification sent"
+else
+    echo "❌ Failed to send Discord notification"
+    exit 1
+fi

package/.claude/settings.json

@@ -0,0 +1,7 @@
+{
+	"statusLine": {
+		"type": "command",
+		"command": ".claude/statusline.sh",
+		"padding": 0
+	}
+}

package/.claude/statusline.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+# Generated by cc-statusline (https://www.npmjs.com/package/@chongdashu/cc-statusline)
+# Custom Claude Code statusline - Created: 2025-08-19T05:45:09.773Z
+# Theme: detailed | Colors: true | Features: directory, git, model, usage, session, tokens
+
+input=$(cat)
+
+# ---- color helpers (TTY-aware, respect NO_COLOR) ----
+use_color=1
+[ -t 1 ] || use_color=0
+[ -n "$NO_COLOR" ] && use_color=0
+
+C() { if [ "$use_color" -eq 1 ]; then printf '\033[%sm' "$1"; fi; }
+RST() { if [ "$use_color" -eq 1 ]; then printf '\033[0m'; fi; }
+
+# ---- basic colors ----
+dir_color() { if [ "$use_color" -eq 1 ]; then printf '\033[1;36m'; fi; }    # cyan
+model_color() { if [ "$use_color" -eq 1 ]; then printf '\033[1;35m'; fi; }  # magenta  
+version_color() { if [ "$use_color" -eq 1 ]; then printf '\033[1;33m'; fi; } # yellow
+rst() { if [ "$use_color" -eq 1 ]; then printf '\033[0m'; fi; }
+
+# ---- time helpers ----
+to_epoch() {
+  ts="$1"
+  if command -v gdate >/dev/null 2>&1; then gdate -d "$ts" +%s 2>/dev/null && return; fi
+  date -u -j -f "%Y-%m-%dT%H:%M:%S%z" "${ts/Z/+0000}" +%s 2>/dev/null && return
+  python3 - "$ts" <<'PY' 2>/dev/null
+import sys, datetime
+s=sys.argv[1].replace('Z','+00:00')
+print(int(datetime.datetime.fromisoformat(s).timestamp()))
+PY
+}
+
+fmt_time_hm() {
+  epoch="$1"
+  if date -r 0 +%s >/dev/null 2>&1; then date -r "$epoch" +"%H:%M"; else date -d "@$epoch" +"%H:%M"; fi
+}
+
+progress_bar() {
+  pct="${1:-0}"; width="${2:-10}"
+  [[ "$pct" =~ ^[0-9]+$ ]] || pct=0; ((pct<0))&&pct=0; ((pct>100))&&pct=100
+  filled=$(( pct * width / 100 )); empty=$(( width - filled ))
+  printf '%*s' "$filled" '' | tr ' ' '='
+  printf '%*s' "$empty" '' | tr ' ' '-'
+}
+
+# git utilities
+num_or_zero() { v="$1"; [[ "$v" =~ ^[0-9]+$ ]] && echo "$v" || echo 0; }
+
+# ---- basics ----
+if command -v jq >/dev/null 2>&1; then
+  current_dir=$(echo "$input" | jq -r '.workspace.current_dir // .cwd // "unknown"' 2>/dev/null | sed "s|^$HOME|~|g")
+  model_name=$(echo "$input" | jq -r '.model.display_name // "Claude"' 2>/dev/null)
+  model_version=$(echo "$input" | jq -r '.model.version // ""' 2>/dev/null)
+else
+  current_dir="unknown"
+  model_name="Claude"; model_version=""
+fi
+
+# ---- git colors ----
+git_color() { if [ "$use_color" -eq 1 ]; then printf '\033[1;32m'; fi; }
+rst() { if [ "$use_color" -eq 1 ]; then printf '\033[0m'; fi; }
+
+# ---- git ----
+git_branch=""
+if git rev-parse --git-dir >/dev/null 2>&1; then
+  git_branch=$(git branch --show-current 2>/dev/null || git rev-parse --short HEAD 2>/dev/null)
+fi
+
+# ---- usage colors ----
+usage_color() { if [ "$use_color" -eq 1 ]; then printf '\033[1;35m'; fi; }
+cost_color() { if [ "$use_color" -eq 1 ]; then printf '\033[1;36m'; fi; }
+session_color() { 
+  rem_pct=$(( 100 - session_pct ))
+  if   (( rem_pct <= 10 )); then SCLR='1;31'
+  elif (( rem_pct <= 25 )); then SCLR='1;33'
+  else                          SCLR='1;32'; fi
+  if [ "$use_color" -eq 1 ]; then printf '\033[%sm' "$SCLR"; fi
+}
+
+# ---- ccusage integration ----
+session_txt=""; session_pct=0; session_bar=""
+cost_usd=""; cost_per_hour=""; tpm=""; tot_tokens=""
+
+if command -v jq >/dev/null 2>&1; then
+  blocks_output=$(npx ccusage@latest blocks --json 2>/dev/null || ccusage blocks --json 2>/dev/null)
+  if [ -n "$blocks_output" ]; then
+    active_block=$(echo "$blocks_output" | jq -c '.blocks[] | select(.isActive == true)' 2>/dev/null | head -n1)
+    if [ -n "$active_block" ]; then
+      cost_usd=$(echo "$active_block" | jq -r '.costUSD // empty')
+      cost_per_hour=$(echo "$active_block" | jq -r '.burnRate.costPerHour // empty')
+      tot_tokens=$(echo "$active_block" | jq -r '.totalTokens // empty')
+      
+      # Session time calculation
+      reset_time_str=$(echo "$active_block" | jq -r '.usageLimitResetTime // .endTime // empty')
+      start_time_str=$(echo "$active_block" | jq -r '.startTime // empty')
+      
+      if [ -n "$reset_time_str" ] && [ -n "$start_time_str" ]; then
+        start_sec=$(to_epoch "$start_time_str"); end_sec=$(to_epoch "$reset_time_str"); now_sec=$(date +%s)
+        total=$(( end_sec - start_sec )); (( total<1 )) && total=1
+        elapsed=$(( now_sec - start_sec )); (( elapsed<0 ))&&elapsed=0; (( elapsed>total ))&&elapsed=$total
+        session_pct=$(( elapsed * 100 / total ))
+        remaining=$(( end_sec - now_sec )); (( remaining<0 )) && remaining=0
+        rh=$(( remaining / 3600 )); rm=$(( (remaining % 3600) / 60 ))
+        end_hm=$(fmt_time_hm "$end_sec")
+        session_txt="$(printf '%dh %dm until reset at %s (%d%%)' "$rh" "$rm" "$end_hm" "$session_pct")"
+        session_bar=$(progress_bar "$session_pct" 10)
+      fi
+    fi
+  fi
+fi
+
+# ---- render statusline ----
+printf '📁 %s%s%s' "$(dir_color)" "$current_dir" "$(rst)"
+# git display
+if [ -n "$git_branch" ]; then
+  printf '  🌿 %s%s%s' "$(git_color)" "$git_branch" "$(rst)"
+fi
+printf '  🤖 %s%s%s' "$(model_color)" "$model_name" "$(rst)"
+if [ -n "$model_version" ] && [ "$model_version" != "null" ]; then
+  printf '  🏷️ %s%s%s' "$(version_color)" "$model_version" "$(rst)"
+fi
+# session time
+if [ -n "$session_txt" ]; then
+  printf '  ⌛ %s%s%s' "$(session_color)" "$session_txt" "$(rst)"
+  printf '  %s[%s]%s' "$(session_color)" "$session_bar" "$(rst)"
+fi
+# cost
+if [ -n "$cost_usd" ] && [[ "$cost_usd" =~ ^[0-9.]+$ ]]; then
+  if [ -n "$cost_per_hour" ] && [[ "$cost_per_hour" =~ ^[0-9.]+$ ]]; then
+    printf '  💵 %s$%.2f ($%.2f/h)%s' "$(cost_color)" "$cost_usd" "$cost_per_hour" "$(rst)"
+  else
+    printf '  💵 %s$%.2f%s' "$(cost_color)" "$cost_usd" "$(rst)"
+  fi
+fi
+# tokens
+if [ -n "$tot_tokens" ] && [[ "$tot_tokens" =~ ^[0-9]+$ ]]; then
+  if [ -n "$tpm" ] && [[ "$tpm" =~ ^[0-9.]+$ ]] && false; then
+    printf '  📊 %s%s tok (%.0f tpm)%s' "$(usage_color)" "$tot_tokens" "$tpm" "$(rst)"
+  else
+    printf '  📊 %s%s tok%s' "$(usage_color)" "$tot_tokens" "$(rst)"
+  fi
+fi

package/.claude/workflows/development-rules.md

@@ -0,0 +1,80 @@
+# Development Rules
+
+## General
+- **File Size Management**: Keep individual code files under 500 lines for optimal context management
+  - Split large files into smaller, focused components
+  - Use composition over inheritance for complex widgets
+  - Extract utility functions into separate modules
+  - Create dedicated service classes for business logic
+- Use `context7` mcp tools for exploring latest docs of plugins/packages
+- Use `gh` bash command to interact with Github features.
+- Use `psql` bash command to query database for debugging.
+- Use `eyes` mcp tools for describing details of images, videos, documents, etc.
+- Use `hands` mcp tools for generating images, videos, documents, etc.
+- Use `brain` mcp tools for sequential thinking, analyzing code, debugging, etc.
+- **[IMPORTANT]** Follow the codebase structure and code standards in `./docs` during implementation
+- **[IMPORTANT]** When you finish the implementation, send a full summary report to Discord channel with `./.claude/send-discord.sh 'Your message here'` script (remember to escape the string).
+- **[IMPORTANT]** Do not just simulate the implementation or mocking them, always implement the real code.
+
+## Architecture Guidelines
+
+### Core Principles
+
+**YAGNI (You Aren't Gonna Need It)**
+- Only implement what's needed now
+- No speculative features
+- Simple, focused solutions
+
+**KISS (Keep It Simple, Stupid)**
+- Straightforward logic
+- No over-engineering
+- Readable code
+
+**DRY (Don't Repeat Yourself)**
+- Reusable components
+- Extract common patterns
+- Centralized logic
+
+## Subagents
+Delegate detailed tasks to these subagents according to their roles & expertises:
+- Use file system (in markdown format) to hand over reports in `./plans/reports` directory from agent to agent with this file name format: `YYMMDD-from-agent-name-to-agent-name-task-name-report.md`.
+- Use `planner` agent to plan for the implementation plan using templates in `./plans/templates/` (`planner` agent can spawn multiple `researcher` agents in parallel to explore different approaches with "Query Fan-Out" technique).
+- Use `database-admin` agent to run tests and analyze the summary report.
+- Use `tester` agent to run tests and analyze the summary report.
+- Use `debugger` agent to collect logs in server or github actions to analyze the summary report.
+- Use `code-reviewer` agent to review code according to the implementation plan.
+- Use `docs-manager` agent to update docs in `./docs` directory if any (espcially for `./docs/codebase-summary.md` when significant changes are made).
+- Use `git-manager` agent to commit and push code changes.
+- Use `project-manager` agent for project's progress tracking, completion verification & TODO status management.
+- **[IMPORTANT]** Always delegate to `project-manager` agent after completing significant features, major milestones, or when requested to update project documentation.
+- **IMPORTANT:** You can intelligently spawn multiple subagents **in parallel** or **chain them sequentially** to handle the tasks efficiently.
+
+## Code Quality Guidelines
+- Read and follow codebase structure and code standards in `./docs`
+- Don't be too harsh on code linting, but make sure there are no syntax errors and code are compilable
+- Prioritize functionality and readability over strict style enforcement and code formatting
+- Use reasonable code quality standards that enhance developer productivity
+- Use try catch error handling & cover security standards
+- Use `code-reviewer` agent to review code after every implementation
+
+## Pre-commit/Push Rules
+- Run linting before commit
+- Run tests before push (DO NOT ignore failed tests just to pass the build or github actions)
+- Keep commits focused on the actual code changes
+- **DO NOT** commit and push any confidential information (such as dotenv files, API keys, database credentials, etc.) to git repository!
+- NEVER automatically add AI attribution signatures like:
+  "🤖 Generated with [Claude Code]"
+  "Co-Authored-By: Claude noreply@anthropic.com"
+  Any AI tool attribution or signature
+- Create clean, professional commit messages without AI references. Use conventional commit format.
+
+## Code Implementation
+
+- Before you start, delegate to `planner` agent to create a implementation plan with TODO tasks in `./plans` directory.
+- When in planning phase, use multiple `researcher` agents in parallel to conduct research on different relevant technical topics and report back to `planner` agent to create implementation plan.
+- Write clean, readable, and maintainable code
+- Follow established architectural patterns
+- Implement features according to specifications
+- Handle edge cases and error scenarios
+- **DO NOT** create new enhanced files, update to the existing files directly.
+- **[IMPORTANT]** After creating or modifying code file, run compile command/script to check for any compile errors.

package/.claude/workflows/documentation-management.md

@@ -0,0 +1,28 @@
+# Project Documentation Management
+
+### Roadmap & Changelog Maintenance
+- **Project Roadmap** (`./docs/development-roadmap.md`): Living document tracking project phases, milestones, and progress
+- **Project Changelog** (`./docs/project-changelog.md`): Detailed record of all significant changes, features, and fixes
+- **System Architecture** (`./docs/system-architecture.md`): Detailed record of all significant changes, features, and fixes
+- **Code Standards** (`./docs/code-standards.md`): Detailed record of all significant changes, features, and fixes
+
+### Automatic Updates Required
+- **After Feature Implementation**: Update roadmap progress status and changelog entries
+- **After Major Milestones**: Review and adjust roadmap phases, update success metrics
+- **After Bug Fixes**: Document fixes in changelog with severity and impact
+- **After Security Updates**: Record security improvements and version updates
+- **Weekly Reviews**: Update progress percentages and milestone statuses
+
+### Documentation Triggers
+The `project-manager` agent MUST update these documents when:
+- A development phase status changes (e.g., from "In Progress" to "Complete")
+- Major features are implemented or released
+- Significant bugs are resolved or security patches applied
+- Project timeline or scope adjustments are made
+- External dependencies or breaking changes occur
+
+### Update Protocol
+1. **Before Updates**: Always read current roadmap and changelog status
+2. **During Updates**: Maintain version consistency and proper formatting
+3. **After Updates**: Verify links, dates, and cross-references are accurate
+4. **Quality Check**: Ensure updates align with actual implementation progress

package/.claude/workflows/orchestration-protocol.md

@@ -0,0 +1,16 @@
+# Orchestration Protocol
+
+#### Sequential Chaining
+Chain subagents when tasks have dependencies or require outputs from previous steps:
+- **Planning → Implementation → Testing → Review**: Use for feature development
+- **Research → Design → Code → Documentation**: Use for new system components
+- Each agent completes fully before the next begins
+- Pass context and outputs between agents in the chain
+
+#### Parallel Execution
+Spawn multiple subagents simultaneously for independent tasks:
+- **Code + Tests + Docs**: When implementing separate, non-conflicting components
+- **Multiple Feature Branches**: Different agents working on isolated features
+- **Cross-platform Development**: iOS and Android specific implementations
+- **Careful Coordination**: Ensure no file conflicts or shared resource contention
+- **Merge Strategy**: Plan integration points before parallel execution begins

package/.claude/workflows/primary-workflow.md

@@ -0,0 +1,41 @@
+# Primary Workflow
+
+#### 1. Code Implementation
+- Before you start, delegate to `planner` agent to create a implementation plan with TODO tasks in `./plans` directory.
+- When in planning phase, use multiple `researcher` agents in parallel to conduct research on different relevant technical topics and report back to `planner` agent to create implementation plan.
+- Write clean, readable, and maintainable code
+- Follow established architectural patterns
+- Implement features according to specifications
+- Handle edge cases and error scenarios
+- **DO NOT** create new enhanced files, update to the existing files directly.
+- **[IMPORTANT]** After creating or modifying code file, run compile command/script to check for any compile errors.
+
+#### 2. Testing
+- Delegate to `tester` agent to run tests and analyze the summary report.
+  - Write comprehensive unit tests
+  - Ensure high code coverage
+  - Test error scenarios
+  - Validate performance requirements
+- Tests are critical for ensuring code quality and reliability, **DO NOT** ignore failing tests just to pass the build.
+- **IMPORTANT:** Always fix failing tests follow the recommendations and delegate to `tester` agent to run tests again, only finish your session when all tests pass.
+
+#### 3. Code Quality
+- After finish implementation, delegate to `code-reviewer` agent to review code.
+- Follow coding standards and conventions
+- Write self-documenting code
+- Add meaningful comments for complex logic
+- Optimize for performance and maintainability
+
+#### 4. Integration
+- Always follow the plan given by `planner` agent
+- Ensure seamless integration with existing code
+- Follow API contracts precisely
+- Maintain backward compatibility
+- Document breaking changes
+- Delegate to `docs-manager` agent to update docs in `./docs` directory if any.
+
+#### 5. Debugging
+- When a user report bugs or issues on the server or a CI/CD pipeline, delegate to `debugger` agent to run tests and analyze the summary report.
+- Read the summary report from `debugger` agent and implement the fix.
+- Delegate to `tester` agent to run tests and analyze the summary report.
+- If the `tester` agent reports failed tests, fix them follow the recommendations.

package/.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - main
+      - master
+  push:
+    branches:
+      - main
+      - master
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install system dependencies
+        run: sudo apt-get update && sudo apt-get install -y libsecret-1-dev
+
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+
+      - name: Run type check
+        run: bun run typecheck
+
+      - name: Run linter
+        run: bun run lint
+
+      - name: Run tests
+        run: bun test
+
+      - name: Build
+        run: bun run build