claudekit-cli 1.0.0 → 1.0.1

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

@@ -1,13 +0,0 @@
----
-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

@@ -1,10 +0,0 @@
----
-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

@@ -1,29 +0,0 @@
----
-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

@@ -1,7 +0,0 @@
----
-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

@@ -1,8 +0,0 @@
----
-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

@@ -1,136 +0,0 @@
-#!/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

@@ -1,64 +0,0 @@
-#!/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

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

package/.claude/statusline.sh

@@ -1,143 +0,0 @@
-#!/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

@@ -1,80 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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/.opencode/command/docs/init.md

@@ -1,11 +0,0 @@
----
-description: Analyze the codebase and create initial documentation
----
-
-Use `docs/` directory as the source of truth for documentation.
-Use `docs-manager` agent to analyze the codebase and create initial documentation:
-- `docs/project-overview-pdr.md`: Project overview and PDR (Product Development Requirements)
-- `docs/codebase-summary.md`: Codebase summary
-- `docs/codebase-structure-architecture-code-standards.md`: Codebase structure, architecture, and code standards
-
-**IMPORTANT**: **Do not** start implementing.

package/.opencode/command/docs/summarize.md

@@ -1,10 +0,0 @@
----
-description: Analyze the codebase and update documentation
----
-
-Use `docs-manager` agent to analyze the codebase and update `docs/codebase-summary.md`
-
-## Notes:
-- Use `docs/` directory as the source of truth for documentation.
-
-**IMPORTANT**: **Do not** start implementing.

package/.opencode/command/docs/update.md

@@ -1,18 +0,0 @@
----
-description: Analyze the codebase and update documentation
----
-
-Use `docs/` directory as the source of truth for documentation.
-Use `docs-manager` agent to analyze the codebase and update documentation:
-- `README.md`: Update README
-- `docs/project-overview-pdr.md`: Update project overview and PDR (Product Development Requirements)
-- `docs/codebase-summary.md`: Update codebase summary
-- `docs/codebase-structure-architecture-code-standards.md`: Update codebase structure, architecture, and code standards
-- Only update `CLAUDE.md` or `AGENTS.md` when requested.
-
-## Additional requests
-<additional_requests>
-  $ARGUMENTS
-</additional_requests>
-
-**IMPORTANT**: **Do not** start implementing.