loki-mode 6.27.2 → 6.28.0

package/README.md

@@ -10,7 +10,7 @@
 [![Autonomi](https://img.shields.io/badge/Autonomi-autonomi.dev-5B4EEA)](https://www.autonomi.dev/)
 [![Docker Pulls](https://img.shields.io/docker/pulls/asklokesh/loki-mode)](https://hub.docker.com/r/asklokesh/loki-mode)
 
-**Current Version: v6.27.0**
+**Current Version: v6.28.0**
 
 ### Traction
 

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.27.0
+# Loki Mode v6.28.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -267,4 +267,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.27.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.28.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.27.2
+6.28.0

package/autonomy/loki

@@ -392,7 +392,7 @@ show_help() {
     echo "  start [PRD]      Start Loki Mode (optionally with PRD file)"
     echo "  quick \"task\"     Quick single-task mode (lightweight, 3 iterations max)"
     echo "  demo             Run interactive demo (~60s simulated session)"
-    echo "  init             Build a PRD interactively or from templates"
+    echo "  init [name]      Project scaffolding with 22 PRD templates"
     echo "  issue <url|num>  [DEPRECATED] Use 'loki run' instead"
     echo "  watch [sec]      Live TUI session monitor (v6.0.0)"
     echo "  export <format>  Export session data: json|markdown|csv|timeline (v6.0.0)"
@@ -6450,268 +6450,412 @@ QPRDEOF
     exec "$RUN_SH" "$quick_prd"
 }
 
-# Interactive PRD builder
+# Project scaffolding (v6.28.0)
 cmd_init() {
     local version=$(get_version)
-    local output_file="./prd.md"
-    local template=""
-    local start_after=false
+    local project_name=""
+    local template_name=""
+    local no_git=false
+    local stdout_mode=false
+    local dry_run=false
+    local list_mode=false
+    local json_mode=false
+
+    # 22 built-in template names (order: simple, standard, complex)
+    local TEMPLATE_NAMES=(
+        simple-todo-app
+        static-landing-page
+        api-only
+        rest-api
+        rest-api-auth
+        cli-tool
+        discord-bot
+        chrome-extension
+        blog-platform
+        full-stack-demo
+        web-scraper
+        data-pipeline
+        dashboard
+        game
+        slack-bot
+        npm-library
+        microservice
+        mobile-app
+        saas-app
+        saas-starter
+        e-commerce
+        ai-chatbot
+    )
+
+    local -A TEMPLATE_LABELS=(
+        [simple-todo-app]="Simple Todo App"
+        [static-landing-page]="Static Landing Page"
+        [api-only]="REST API (No Frontend)"
+        [rest-api]="REST API"
+        [rest-api-auth]="REST API with Auth"
+        [cli-tool]="CLI Tool"
+        [discord-bot]="Discord Bot"
+        [chrome-extension]="Chrome Extension"
+        [blog-platform]="Blog Platform"
+        [full-stack-demo]="Full-Stack Demo"
+        [web-scraper]="Web Scraper"
+        [data-pipeline]="Data Pipeline"
+        [dashboard]="Analytics Dashboard"
+        [game]="Browser Game"
+        [slack-bot]="Slack Bot"
+        [npm-library]="npm Library"
+        [microservice]="Microservice"
+        [mobile-app]="Mobile App"
+        [saas-app]="SaaS Application"
+        [saas-starter]="SaaS Starter Kit"
+        [e-commerce]="E-Commerce Store"
+        [ai-chatbot]="AI Chatbot (RAG)"
+    )
+
+    local template_count=${#TEMPLATE_NAMES[@]}
 
     # Parse arguments
     while [[ $# -gt 0 ]]; do
         case "$1" in
-            --output|-o)
-                if [[ -n "${2:-}" ]]; then
-                    output_file="$2"
-                    shift 2
-                else
-                    echo -e "${RED}--output requires a file path${NC}"
-                    exit 1
-                fi
+            --list)
+                list_mode=true
+                shift
+                ;;
+            --json)
+                json_mode=true
+                list_mode=true
+                shift
                 ;;
             --template|-t)
                 if [[ -n "${2:-}" ]]; then
-                    template="$2"
+                    template_name="$2"
                     shift 2
                 else
-                    echo -e "${RED}--template requires a template name${NC}"
+                    echo -e "${RED}--template requires a value${NC}"
                     exit 1
                 fi
                 ;;
-            --start|-s)
-                start_after=true
+            --no-git)
+                no_git=true
                 shift
                 ;;
-            --list-templates)
-                _list_templates
-                exit 0
+            --stdout)
+                stdout_mode=true
+                shift
+                ;;
+            --dry-run)
+                dry_run=true
+                shift
                 ;;
             --help|-h)
-                echo -e "${BOLD}loki init${NC} - Interactive PRD builder"
+                echo -e "${BOLD}loki init${NC} - Project scaffolding with PRD templates"
+                echo ""
+                echo "Usage: loki init [project-name] [--template TYPE]"
+                echo ""
+                echo "Creates a new project scaffold with a PRD, config directory, and README."
+                echo "If no project-name is given, scaffolds the current directory."
                 echo ""
-                echo "Usage: loki init [options]"
+                echo "What it creates:"
+                echo "  prd.md                   PRD from selected template"
+                echo "  .loki/loki.config.json   Project configuration"
+                echo "  README.md                Project README stub"
+                echo "  .gitignore               Git ignore rules (with git init)"
                 echo ""
                 echo "Options:"
-                echo "  --output, -o FILE       Output file (default: ./prd.md)"
-                echo "  --template, -t NAME     Start from a template"
-                echo "  --start, -s             Start loki mode after generating PRD"
-                echo "  --list-templates        List available templates"
+                echo "  --template, -t TYPE     Template name (e.g., saas-app, cli-tool)"
+                echo "  --no-git                Skip git init"
+                echo "  --stdout                Print PRD to stdout instead of writing files"
+                echo "  --list                  List all available templates"
+                echo "  --json                  Machine-readable template list (JSON)"
+                echo "  --dry-run               Show what would be created without doing it"
+                echo "  --help, -h              Show this help"
                 echo ""
                 echo "Examples:"
-                echo "  loki init                         Interactive PRD builder"
-                echo "  loki init -t saas-starter         Start from SaaS template"
-                echo "  loki init -o docs/requirements.md Custom output path"
-                echo "  loki init --start                 Build PRD and start immediately"
+                echo "  loki init my-saas --template saas-app    Create my-saas/ with SaaS PRD"
+                echo "  loki init --template cli-tool            Scaffold current dir with CLI PRD"
+                echo "  loki init my-app                         Create my-app/ (prompts for template)"
+                echo "  loki init --list                         Show all $template_count templates"
+                echo "  loki init --template rest-api --stdout   Print REST API PRD to stdout"
+                echo "  loki init my-app --dry-run               Preview without writing anything"
                 exit 0
                 ;;
-            *)
+            -*)
                 echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki init --help' for usage."
                 exit 1
                 ;;
+            *)
+                if [[ -z "$project_name" ]]; then
+                    project_name="$1"
+                else
+                    echo -e "${RED}Too many arguments${NC}"
+                    echo "Usage: loki init [project-name] [--template TYPE]"
+                    exit 1
+                fi
+                shift
+                ;;
         esac
     done
 
-    # If template specified, copy it
-    if [ -n "$template" ]; then
-        local template_file=""
-        # Check templates/ directory
-        for dir in "$SKILL_DIR/templates" "$SKILL_DIR/examples"; do
-            if [ -f "$dir/$template.md" ]; then
-                template_file="$dir/$template.md"
-                break
-            elif [ -f "$dir/${template}" ]; then
-                template_file="$dir/${template}"
-                break
+    # Handle --list / --json
+    if $list_mode; then
+        if $json_mode; then
+            echo "["
+            local first=true
+            for tname in "${TEMPLATE_NAMES[@]}"; do
+                if $first; then
+                    first=false
+                else
+                    echo ","
+                fi
+                printf '  {"name": "%s", "label": "%s"}' "$tname" "${TEMPLATE_LABELS[$tname]}"
+            done
+            echo ""
+            echo "]"
+        else
+            echo -e "${BOLD}Available PRD Templates ($template_count)${NC}"
+            echo ""
+            echo -e "  ${DIM}Simple:${NC}"
+            local idx=1
+            for tname in "${TEMPLATE_NAMES[@]}"; do
+                if [[ "$tname" == "rest-api" ]]; then
+                    echo -e "  ${DIM}Standard:${NC}"
+                elif [[ "$tname" == "mobile-app" ]]; then
+                    echo -e "  ${DIM}Complex:${NC}"
+                fi
+                printf "  %2d. ${CYAN}%-22s${NC} %s\n" "$idx" "$tname" "${TEMPLATE_LABELS[$tname]}"
+                idx=$((idx + 1))
+            done
+            echo ""
+            echo "Usage: loki init [project-name] --template <name>"
+        fi
+        exit 0
+    fi
+
+    # Interactive template picker if no template specified
+    if [[ -z "$template_name" ]]; then
+        echo -e "${BOLD}Loki Mode v$version - Project Scaffolding${NC}"
+        echo ""
+        echo "Select a PRD template:"
+        echo ""
+        echo -e "  ${DIM}Simple:${NC}"
+        local idx=1
+        for tname in "${TEMPLATE_NAMES[@]}"; do
+            if [[ "$tname" == "rest-api" ]]; then
+                echo -e "  ${DIM}Standard:${NC}"
+            elif [[ "$tname" == "mobile-app" ]]; then
+                echo -e "  ${DIM}Complex:${NC}"
             fi
+            printf "  %2d. %-22s %s\n" "$idx" "$tname" "${TEMPLATE_LABELS[$tname]}"
+            idx=$((idx + 1))
         done
+        echo ""
+        echo -e -n "${BOLD}Choose [1-$template_count]:${NC} "
+        read -r choice
 
-        if [ -z "$template_file" ]; then
-            echo -e "${RED}Template not found: $template${NC}"
-            echo ""
-            _list_templates
+        if ! [[ "$choice" =~ ^[0-9]+$ ]] || [ "$choice" -lt 1 ] || [ "$choice" -gt "$template_count" ]; then
+            echo -e "${RED}Invalid choice. Enter a number between 1 and $template_count.${NC}"
             exit 1
         fi
 
-        cp "$template_file" "$output_file"
-        echo -e "${GREEN}Created${NC} $output_file from template: $template"
-        echo -e "${DIM}Edit the file to customize it for your project${NC}"
-
-        if [ "$start_after" = true ]; then
-            echo ""
-            echo -e "${CYAN}Starting Loki Mode...${NC}"
-            exec "$0" start "$output_file"
-        fi
-        exit 0
+        template_name="${TEMPLATE_NAMES[$((choice - 1))]}"
+        echo ""
+        echo -e "Selected: ${CYAN}$template_name${NC} (${TEMPLATE_LABELS[$template_name]})"
     fi
 
-    # Interactive mode
-    echo -e "${BOLD}Loki Mode v$version - PRD Builder${NC}"
-    echo ""
-    echo -e "${CYAN}Answer a few questions to generate your PRD.${NC}"
-    echo ""
+    # Resolve template file
+    local template_file=""
+    for dir in "$SKILL_DIR/templates" "$SKILL_DIR/examples"; do
+        if [[ -f "$dir/${template_name}.md" ]]; then
+            template_file="$dir/${template_name}.md"
+            break
+        fi
+    done
 
-    # Project name
-    echo -e -n "${BOLD}Project name:${NC} "
-    read -r project_name
-    if [ -z "$project_name" ]; then
-        echo -e "${RED}Project name is required${NC}"
+    if [[ -z "$template_file" ]]; then
+        echo -e "${RED}Unknown template: $template_name${NC}"
+        echo ""
+        echo "Available templates:"
+        for tname in "${TEMPLATE_NAMES[@]}"; do
+            echo "  $tname"
+        done
+        echo ""
+        echo "Run 'loki init --list' for details."
         exit 1
     fi
 
-    # Description
-    echo -e -n "${BOLD}One-line description:${NC} "
-    read -r description
+    # Read template content
+    local prd_content
+    prd_content=$(cat "$template_file")
 
-    # Project type
-    echo ""
-    echo -e "${BOLD}Project type:${NC}"
-    echo "  1) Web application (full-stack)"
-    echo "  2) REST API (backend only)"
-    echo "  3) CLI tool"
-    echo "  4) Landing page (static)"
-    echo "  5) Mobile app (React Native)"
-    echo "  6) Browser extension"
-    echo "  7) Other"
-    echo -e -n "Choose [1-7]: "
-    read -r type_choice
-
-    local project_type=""
-    local default_stack=""
-    case "$type_choice" in
-        1) project_type="Web Application"; default_stack="Next.js + TypeScript + Prisma + PostgreSQL" ;;
-        2) project_type="REST API"; default_stack="Node.js + Express + TypeScript + SQLite" ;;
-        3) project_type="CLI Tool"; default_stack="Node.js + TypeScript + Commander.js" ;;
-        4) project_type="Landing Page"; default_stack="HTML + CSS + JavaScript (no framework)" ;;
-        5) project_type="Mobile App"; default_stack="React Native + TypeScript + Expo" ;;
-        6) project_type="Browser Extension"; default_stack="Chrome Manifest V3 + TypeScript" ;;
-        7) project_type="Custom"; default_stack="" ;;
-        *) project_type="Web Application"; default_stack="Next.js + TypeScript + Prisma + PostgreSQL" ;;
-    esac
+    # --stdout mode: just print PRD and exit
+    if $stdout_mode; then
+        echo "$prd_content"
+        exit 0
+    fi
 
-    # Tech stack
-    echo ""
-    if [ -n "$default_stack" ]; then
-        echo -e -n "${BOLD}Tech stack${NC} [${DIM}$default_stack${NC}]: "
-        read -r tech_stack
-        if [ -z "$tech_stack" ]; then
-            tech_stack="$default_stack"
-        fi
+    # Determine target directory
+    local target_dir
+    if [[ -n "$project_name" ]]; then
+        target_dir="$(pwd)/$project_name"
     else
-        echo -e -n "${BOLD}Tech stack:${NC} "
-        read -r tech_stack
+        target_dir="$(pwd)"
     fi
 
-    # Features
-    echo ""
-    echo -e "${BOLD}Key features${NC} (enter one per line, empty line to finish):"
-    local features=()
-    local feat_num=1
-    while true; do
-        echo -e -n "  ${feat_num}. "
-        read -r feature
-        if [ -z "$feature" ]; then
-            break
+    # Build config JSON
+    local config_json
+    config_json=$(cat <<ENDJSON
+{
+  "version": "$version",
+  "template": "$template_name",
+  "created": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "provider": "claude",
+  "complexity": "auto",
+  "quality_gates": true,
+  "parallel_mode": false,
+  "dashboard": true
+}
+ENDJSON
+)
+
+    # Build README content
+    local display_name="${project_name:-$(basename "$target_dir")}"
+    local readme_content
+    readme_content=$(cat <<ENDREADME
+# $display_name
+
+Built with [Loki Mode](https://www.autonomi.dev/) using the \`$template_name\` template.
+
+## Getting Started
+
+\`\`\`bash
+# Review the PRD
+cat prd.md
+
+# Launch autonomous development
+claude --dangerously-skip-permissions
+# Then: "Loki Mode with PRD at prd.md"
+
+# Or via CLI
+loki start prd.md
+\`\`\`
+
+## Project Structure
+
+This project was scaffolded by \`loki init\`. Key files:
+
+- \`prd.md\` - Product Requirements Document
+- \`.loki/loki.config.json\` - Loki Mode configuration
+ENDREADME
+)
+
+    # Build gitignore content
+    local gitignore_content
+    gitignore_content=$(cat <<'ENDGITIGNORE'
+# Dependencies
+node_modules/
+venv/
+__pycache__/
+
+# Build output
+dist/
+build/
+*.egg-info/
+
+# Loki Mode runtime state (keep .loki/loki.config.json)
+.loki/state/
+.loki/memory/episodic/
+.loki/metrics/
+.loki/queue/
+.loki/sessions/
+.loki/logs/
+
+# Environment
+.env
+.env.local
+
+# OS
+.DS_Store
+Thumbs.db
+ENDGITIGNORE
+)
+
+    # --dry-run mode: show what would be created
+    if $dry_run; then
+        echo -e "${BOLD}Dry run: loki init${NC}"
+        echo ""
+        if [[ -n "$project_name" ]]; then
+            echo -e "  ${GREEN}CREATE${NC} $target_dir/"
         fi
-        features+=("$feature")
-        feat_num=$((feat_num + 1))
-        if [ $feat_num -gt 10 ]; then
-            echo -e "${DIM}  (max 10 features)${NC}"
-            break
+        echo -e "  ${GREEN}CREATE${NC} $target_dir/prd.md (${TEMPLATE_LABELS[$template_name]} template)"
+        echo -e "  ${GREEN}CREATE${NC} $target_dir/.loki/"
+        echo -e "  ${GREEN}CREATE${NC} $target_dir/.loki/loki.config.json"
+        echo -e "  ${GREEN}CREATE${NC} $target_dir/README.md"
+        if ! $no_git; then
+            if [[ -n "$project_name" ]] || ! git rev-parse --git-dir &>/dev/null; then
+                echo -e "  ${GREEN}CREATE${NC} $target_dir/.gitignore"
+                echo -e "  ${GREEN}RUN${NC}    git init"
+            fi
         fi
-    done
-
-    if [ ${#features[@]} -eq 0 ]; then
-        echo -e "${RED}At least one feature is required${NC}"
-        exit 1
+        echo ""
+        echo "Run without --dry-run to create these files."
+        exit 0
     fi
 
-    # Out of scope
-    echo ""
-    echo -e "${BOLD}Out of scope${NC} (enter one per line, empty line to finish):"
-    local exclusions=()
-    local exc_num=1
-    while true; do
-        echo -e -n "  ${exc_num}. "
-        read -r exclusion
-        if [ -z "$exclusion" ]; then
-            break
-        fi
-        exclusions+=("$exclusion")
-        exc_num=$((exc_num + 1))
-        if [ $exc_num -gt 10 ]; then
-            break
+    # Create project directory if project name given
+    if [[ -n "$project_name" ]]; then
+        if [[ -d "$target_dir" ]]; then
+            echo -e "${RED}Directory already exists: $target_dir${NC}"
+            exit 1
         fi
-    done
+        mkdir -p "$target_dir"
+    fi
 
-    # Generate PRD
-    {
-        echo "# PRD: $project_name"
-        echo ""
-        echo "## Overview"
-        echo "$description"
-        echo ""
-        echo "## Project Type"
-        echo "$project_type"
-        echo ""
-        echo "## Target Users"
-        echo "Developers and end-users who need $description"
-        echo ""
-        echo "## Features"
-        echo ""
-        echo "### MVP Features"
-        local i=1
-        for feat in "${features[@]}"; do
-            echo "$i. **$(echo "$feat" | awk '{print toupper(substr($0,1,1)) substr($0,2)}')** - $feat"
-            i=$((i + 1))
-        done
-        echo ""
-        echo "## Tech Stack"
-        echo "- $tech_stack"
-        echo ""
-        echo "## Requirements"
-        echo "- All features functional and tested"
-        echo "- Clean, well-structured code"
-        echo "- Error handling with user feedback"
-        echo "- Input validation where applicable"
-        echo ""
-        echo "## Testing"
-        echo "- Unit tests for core functionality"
-        echo "- Integration tests for API endpoints (if applicable)"
-        echo "- Manual testing checklist"
-        echo ""
-        echo "## Out of Scope"
-        if [ ${#exclusions[@]} -gt 0 ]; then
-            for exc in "${exclusions[@]}"; do
-                echo "- $exc"
-            done
-        else
-            echo "- Authentication (unless specified in features)"
-            echo "- Cloud deployment"
-            echo "- Performance optimization"
+    # Create .loki config directory
+    mkdir -p "$target_dir/.loki"
+
+    # Write files
+    echo "$prd_content" > "$target_dir/prd.md"
+    echo "$config_json" > "$target_dir/.loki/loki.config.json"
+
+    # Only write README if it does not already exist
+    if [[ ! -f "$target_dir/README.md" ]]; then
+        echo "$readme_content" > "$target_dir/README.md"
+    fi
+
+    # Git init (unless --no-git or already in a git repo)
+    local did_git_init=false
+    if ! $no_git; then
+        if [[ -n "$project_name" ]] || ! git rev-parse --git-dir &>/dev/null; then
+            echo "$gitignore_content" > "$target_dir/.gitignore"
+            (cd "$target_dir" && git init -q)
+            did_git_init=true
         fi
-        echo ""
-        echo "## Success Criteria"
-        echo "- All MVP features working"
-        echo "- Tests passing"
-        echo "- No console errors"
-        echo "- Code review passes"
-        echo ""
-        echo "---"
-        echo ""
-        echo "**Generated by:** loki init v$(get_version)"
-    } > "$output_file"
+    fi
 
+    # Print summary
     echo ""
-    echo -e "${GREEN}PRD generated:${NC} $output_file"
+    echo -e "${GREEN}Project scaffolded:${NC} $target_dir"
     echo ""
-
-    if [ "$start_after" = true ]; then
-        echo -e "${CYAN}Starting Loki Mode...${NC}"
-        exec "$0" start "$output_file"
+    echo "  Files created:"
+    echo -e "    prd.md                   ${DIM}${TEMPLATE_LABELS[$template_name]} template${NC}"
+    echo -e "    .loki/loki.config.json   ${DIM}project configuration${NC}"
+    if [[ ! -f "$target_dir/README.md" ]] || [[ -n "$project_name" ]]; then
+        echo -e "    README.md                ${DIM}project readme${NC}"
+    fi
+    if $did_git_init; then
+        echo -e "    .gitignore               ${DIM}git ignore rules${NC}"
+        echo -e "    ${DIM}git repo initialized${NC}"
+    fi
+    echo ""
+    echo "Next steps:"
+    if [[ -n "$project_name" ]]; then
+        echo -e "  1. ${BOLD}cd $project_name${NC}"
+        echo -e "  2. Review and edit: ${BOLD}prd.md${NC}"
+        echo -e "  3. Run: ${BOLD}loki start prd.md${NC}"
     else
-        echo "Next steps:"
-        echo -e "  1. Review and edit: ${BOLD}$output_file${NC}"
-        echo -e "  2. Start Loki Mode: ${BOLD}loki start $output_file${NC}"
+        echo -e "  1. Review and edit: ${BOLD}prd.md${NC}"
+        echo -e "  2. Run: ${BOLD}loki start prd.md${NC}"
     fi
 }
 
@@ -6744,34 +6888,9 @@ cmd_dogfood() {
     bash "$stats_script" $json_flag
 }
 
-# List available templates
+# List available templates (legacy helper, kept for backward compat)
 _list_templates() {
-    echo -e "${BOLD}Available Templates${NC}"
-    echo ""
-    local found=false
-    declare -A seen_names
-    for dir in "$SKILL_DIR/templates" "$SKILL_DIR/examples"; do
-        if [ -d "$dir" ]; then
-            for f in "$dir"/*.md; do
-                if [ -f "$f" ] && [ "$(basename "$f")" != "README.md" ]; then
-                    local name=$(basename "$f" .md)
-                    # Skip duplicates (templates/ takes priority over examples/)
-                    if [[ -n "${seen_names[$name]:-}" ]]; then
-                        continue
-                    fi
-                    seen_names[$name]=1
-                    local title=$(head -1 "$f" | sed -E 's/^#+ *//')
-                    echo -e "  ${CYAN}$name${NC} - $title"
-                    found=true
-                fi
-            done
-        fi
-    done
-    if [ "$found" = false ]; then
-        echo "  No templates found"
-    fi
-    echo ""
-    echo "Usage: loki init --template <name>"
+    cmd_init --list
 }
 
 # Watchdog: process health monitoring

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.27.2"
+__version__ = "6.28.0"
 
 # Expose the control app for easy import
 try:

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.27.2
+**Version:** v6.28.0
 
 ---
 

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.27.0'
+__version__ = '6.28.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.27.2",
+  "version": "6.28.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",

package/templates/dashboard.md

@@ -0,0 +1,42 @@
+# PRD: Analytics Dashboard
+
+## Overview
+A real-time analytics dashboard that visualizes key business metrics with interactive charts, filterable data tables, and customizable dashboard layouts.
+
+## Target Users
+- Product managers tracking feature adoption and user engagement
+- Business analysts monitoring KPIs and trends
+- Operations teams watching system health and performance metrics
+
+## Core Features
+1. **Interactive Charts** - Line, bar, pie, and area charts with hover tooltips and click-to-drill-down
+2. **Data Tables** - Sortable, filterable, and paginated tables with column visibility controls
+3. **Date Range Picker** - Filter all dashboard data by custom date ranges with preset shortcuts
+4. **Real-Time Updates** - WebSocket connection for live metric updates without page refresh
+5. **Dashboard Layouts** - Drag-and-drop widget arrangement with save and load layout presets
+6. **Export** - Export charts as PNG images and tables as CSV files
+7. **Responsive Design** - Fully functional on desktop, tablet, and mobile screen sizes
+
+## Technical Requirements
+- React 18 with TypeScript
+- Recharts or Chart.js for data visualization
+- TanStack Table for data tables
+- WebSocket for real-time updates
+- TailwindCSS for styling
+- Express backend serving mock data API
+- LocalStorage for saved layouts
+
+## Quality Gates
+- Unit tests for data transformation and formatting utilities
+- Component tests for chart and table rendering
+- E2E tests for date filtering and layout persistence (Playwright)
+- Responsive design tested at 3 breakpoints (mobile, tablet, desktop)
+- Accessibility: all charts have aria labels, tables are keyboard navigable
+
+## Success Metrics
+- Dashboard loads with sample data and renders all chart types
+- Date range filter updates all widgets simultaneously
+- Real-time updates reflect in charts within 2 seconds
+- Drag-and-drop layout changes persist across page reloads
+- CSV and PNG exports contain accurate data
+- All tests pass

package/templates/data-pipeline.md

@@ -0,0 +1,42 @@
+# PRD: Data Pipeline
+
+## Overview
+An ETL data pipeline that ingests data from multiple sources, transforms it through configurable processing steps, and loads results into a target data store with monitoring and error recovery.
+
+## Target Users
+- Data engineers building batch or streaming pipelines
+- Analysts automating data transformation workflows
+- Teams consolidating data from multiple sources
+
+## Core Features
+1. **Multi-Source Ingestion** - Read from CSV files, JSON APIs, PostgreSQL databases, and S3 buckets
+2. **Configurable Transforms** - Chain transformation steps: filter, map, aggregate, join, and deduplicate
+3. **Schema Validation** - Validate incoming data against defined schemas, quarantine invalid records
+4. **Incremental Processing** - Track watermarks for incremental loads, skip already-processed records
+5. **Error Recovery** - Dead letter queue for failed records, automatic retry with configurable policies
+6. **Pipeline Monitoring** - Metrics for records processed, errors, throughput, and pipeline duration
+7. **Scheduling** - Cron-based scheduling with dependency management between pipeline stages
+
+## Technical Requirements
+- Python 3.10+ with type hints
+- Pydantic for schema validation
+- SQLAlchemy for database connections
+- Click for CLI interface
+- YAML pipeline definitions
+- SQLite for pipeline state and metadata
+- Structured JSON logging
+
+## Quality Gates
+- Unit tests for each transform function
+- Integration tests with sample datasets
+- Schema validation tested with valid and invalid records
+- Incremental processing verified across multiple runs
+- Dead letter queue captures all failure categories
+
+## Success Metrics
+- Pipeline processes sample dataset end-to-end without errors
+- Invalid records quarantined with descriptive error messages
+- Incremental runs process only new records
+- Metrics accurately reflect processing statistics
+- Pipeline resumes correctly after interruption
+- All tests pass

package/templates/game.md

@@ -0,0 +1,42 @@
+# PRD: Browser Game
+
+## Overview
+A browser-based 2D game with player controls, enemy AI, scoring, levels, and persistent high scores. Runs entirely client-side with no server required.
+
+## Target Users
+- Casual gamers looking for a quick browser-based experience
+- Game developers learning 2D game architecture patterns
+- Developers exploring canvas-based rendering and game loops
+
+## Core Features
+1. **Player Controls** - Keyboard input for movement and actions with configurable key bindings
+2. **Game Loop** - Fixed-timestep update loop with requestAnimationFrame rendering at 60fps
+3. **Enemy AI** - Multiple enemy types with distinct movement patterns and difficulty scaling
+4. **Collision Detection** - Axis-aligned bounding box (AABB) collision between sprites
+5. **Scoring and Levels** - Point system with level progression, increasing difficulty per level
+6. **High Scores** - Persistent leaderboard stored in localStorage with name entry
+7. **Sound Effects** - Audio feedback for actions, collisions, and level completion using Web Audio API
+
+## Technical Requirements
+- HTML5 Canvas for rendering
+- Vanilla TypeScript (no game engine dependency)
+- Web Audio API for sound
+- LocalStorage for high scores and settings
+- Asset pipeline for sprites and audio files
+- Responsive canvas sizing
+- No server required (static files only)
+
+## Quality Gates
+- Unit tests for collision detection, scoring, and level progression logic
+- Game loop maintains consistent frame timing under load
+- All sprite assets load without errors
+- Controls responsive on both keyboard and touch (mobile)
+- No memory leaks during extended play sessions
+
+## Success Metrics
+- Game starts, plays, and ends with proper state transitions
+- Player can move, shoot, and interact with enemies
+- Score increments correctly and persists in high score table
+- Level progression increases difficulty noticeably
+- Game runs at stable 60fps on modern browsers
+- All tests pass

package/templates/microservice.md

@@ -0,0 +1,43 @@
+# PRD: Microservice
+
+## Overview
+A containerized microservice with health checks, structured logging, graceful shutdown, and observability. Follows twelve-factor app principles for cloud-native deployment.
+
+## Target Users
+- Backend engineers building distributed systems
+- Teams decomposing monoliths into microservices
+- DevOps engineers designing cloud-native architectures
+
+## Core Features
+1. **HTTP API** - RESTful endpoints with request validation, error handling, and content negotiation
+2. **Health Checks** - Liveness and readiness probe endpoints for container orchestration
+3. **Structured Logging** - JSON-formatted logs with correlation IDs, log levels, and context fields
+4. **Graceful Shutdown** - Handle SIGTERM/SIGINT with connection draining and cleanup
+5. **Configuration** - Environment-variable-based configuration with validation on startup
+6. **Database Integration** - Connection pooling, migrations, and repository pattern for data access
+7. **Observability** - Prometheus metrics endpoint with request duration, error rate, and custom counters
+
+## Technical Requirements
+- Node.js with Express and TypeScript
+- Docker and docker-compose for local development
+- Prisma ORM with PostgreSQL
+- Prometheus client for metrics
+- pino for structured logging
+- Dockerfile with multi-stage build
+- Health check middleware
+
+## Quality Gates
+- Unit tests for business logic and middleware
+- Integration tests with test database
+- Docker image builds and starts successfully
+- Health check endpoints return correct status codes
+- Graceful shutdown completes within timeout
+- Metrics endpoint serves valid Prometheus format
+
+## Success Metrics
+- Service starts in Docker and responds to API requests
+- Health probes return healthy status after startup
+- Logs are valid JSON with correlation IDs across requests
+- Graceful shutdown drains connections without dropping requests
+- Prometheus can scrape metrics endpoint
+- All tests pass

package/templates/npm-library.md

@@ -0,0 +1,43 @@
+# PRD: npm Library
+
+## Overview
+A well-structured npm package with TypeScript support, comprehensive documentation, tree-shakeable exports, and automated publishing. Designed as a reusable utility library.
+
+## Target Users
+- JavaScript and TypeScript developers looking for reusable utilities
+- Teams standardizing shared logic across multiple projects
+- Open source contributors publishing packages to npm
+
+## Core Features
+1. **TypeScript First** - Written in TypeScript with generated .d.ts declaration files
+2. **Dual Format** - Publish both ESM and CommonJS builds for maximum compatibility
+3. **Tree Shaking** - Named exports with proper sideEffects configuration for optimal bundling
+4. **Comprehensive Docs** - Auto-generated API documentation from TSDoc comments
+5. **Semantic Versioning** - Automated changelog generation and version bumping
+6. **Zero Dependencies** - No runtime dependencies for minimal install footprint
+7. **Playground** - Interactive examples in a docs site for trying the library
+
+## Technical Requirements
+- TypeScript 5+ with strict mode
+- tsup for dual ESM/CJS builds
+- Vitest for testing
+- typedoc for API documentation generation
+- changesets for version management
+- GitHub Actions for CI/CD and npm publishing
+- package.json exports map for subpath exports
+
+## Quality Gates
+- Unit tests with 90%+ code coverage
+- Type tests verifying public API type signatures
+- Bundle size tracked and budgeted (fail CI if over limit)
+- ESM and CJS builds both importable in Node.js
+- TypeScript declarations compile cleanly in consuming projects
+- Documentation generated without warnings
+
+## Success Metrics
+- Package installs and imports correctly in ESM and CJS projects
+- All public functions have TSDoc comments and generated docs
+- Test coverage exceeds 90% across all modules
+- Bundle size stays under defined budget
+- Changelog accurately reflects changes between versions
+- All tests pass

package/templates/slack-bot.md

@@ -0,0 +1,42 @@
+# PRD: Slack Bot
+
+## Overview
+A Slack bot that responds to commands, processes events, and integrates with external services. Supports slash commands, interactive messages, and scheduled notifications.
+
+## Target Users
+- Teams automating workflows through Slack
+- Developers building internal tools for Slack workspaces
+- Organizations standardizing team communication and processes
+
+## Core Features
+1. **Slash Commands** - Register and handle custom slash commands with argument parsing
+2. **Event Handling** - Listen for message events, reactions, channel joins, and user mentions
+3. **Interactive Messages** - Send messages with buttons, menus, and modals for user input
+4. **Scheduled Messages** - Schedule recurring notifications and reminders with cron syntax
+5. **External Integrations** - Connect to REST APIs and databases to fetch and display data
+6. **Help System** - Built-in help command listing all available commands and their usage
+7. **Error Reporting** - Log errors and send admin notifications when commands fail
+
+## Technical Requirements
+- Node.js with TypeScript
+- Bolt for Slack SDK (official Slack framework)
+- Express for webhook endpoints
+- SQLite for persistent storage (schedules, user preferences)
+- Environment-based configuration for tokens and signing secrets
+- Structured logging with request context
+- Socket Mode for development, HTTP for production
+
+## Quality Gates
+- Unit tests for command handlers and argument parsers
+- Integration tests with Slack API mocks
+- Interactive message flows tested end-to-end
+- Error handling verified for invalid inputs and API failures
+- Rate limiting compliance with Slack API limits
+
+## Success Metrics
+- Bot responds to all registered slash commands
+- Event handlers process messages and reactions correctly
+- Interactive modals collect and persist user input
+- Scheduled messages fire at configured times
+- Error notifications reach admin channel
+- All tests pass

package/templates/web-scraper.md

@@ -0,0 +1,42 @@
+# PRD: Web Scraper Tool
+
+## Overview
+A configurable web scraping tool that extracts structured data from websites, handles pagination, respects robots.txt, and exports results in multiple formats.
+
+## Target Users
+- Data analysts collecting web data for research
+- Developers building data pipelines from web sources
+- Marketers monitoring competitor pricing or content
+
+## Core Features
+1. **Configurable Extraction** - Define scraping targets with CSS selectors or XPath expressions in a config file
+2. **Pagination Handling** - Automatically follow next-page links or infinite scroll patterns
+3. **Rate Limiting** - Configurable request delays and concurrent connection limits to avoid blocking
+4. **Robots.txt Compliance** - Parse and respect robots.txt rules, with override flag for allowed domains
+5. **Multi-Format Export** - Export scraped data as JSON, CSV, or SQLite database
+6. **Retry and Error Handling** - Automatic retry with exponential backoff for failed requests
+7. **Proxy Support** - Rotate through proxy list for distributed scraping
+
+## Technical Requirements
+- Python 3.10+ with async/await
+- httpx for async HTTP requests
+- BeautifulSoup4 and lxml for HTML parsing
+- SQLite for persistent storage
+- YAML configuration files
+- CLI interface with argparse
+- Structured logging
+
+## Quality Gates
+- Unit tests for parser, config loader, and export functions
+- Integration tests with mock HTTP server
+- Robots.txt parser tested against edge cases
+- Rate limiter verified with timing assertions
+- Export format validation for JSON, CSV, and SQLite
+
+## Success Metrics
+- Scraper extracts data matching CSS selector configuration
+- Pagination follows links and collects all pages
+- Rate limiting maintains configured request interval
+- Robots.txt rules correctly block disallowed paths
+- All export formats contain valid, complete data
+- All tests pass