clasp-ai 0.0.1 → 0.7.1

package/scripts/stream-parser.sh

@@ -0,0 +1,304 @@
+#!/bin/bash
+# CLASP Stream-JSON Parser
+# Converts Claude Code stream-json output to human-readable format
+# Based on MANA stream-parser.sh v4.0
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+MAGENTA='\033[0;35m'
+WHITE='\033[1;37m'
+GRAY='\033[0;90m'
+NC='\033[0m' # No Color
+BOLD='\033[1m'
+DIM='\033[2m'
+
+# Track state
+CURRENT_TOOL=""
+IN_THINKING=false
+
+# Process each line
+while IFS= read -r line; do
+    # Skip empty lines
+    [ -z "$line" ] && continue
+
+    # Try to parse as JSON
+    if ! echo "$line" | jq -e . >/dev/null 2>&1; then
+        # Not JSON, print as-is
+        echo "$line"
+        continue
+    fi
+
+    # Extract type
+    TYPE=$(echo "$line" | jq -r '.type // empty' 2>/dev/null)
+
+    case "$TYPE" in
+        "system")
+            # System init message - show abbreviated info
+            SUBTYPE=$(echo "$line" | jq -r '.subtype // empty' 2>/dev/null)
+            if [ "$SUBTYPE" = "init" ]; then
+                SESSION=$(echo "$line" | jq -r '.session_id // empty' 2>/dev/null)
+                MODEL=$(echo "$line" | jq -r '.model // empty' 2>/dev/null)
+                VERSION=$(echo "$line" | jq -r '.claude_code_version // empty' 2>/dev/null)
+                TOOL_COUNT=$(echo "$line" | jq -r '.tools | length // 0' 2>/dev/null)
+                MCP_SERVERS=$(echo "$line" | jq -r '.mcp_servers | map(.name) | join(", ") // empty' 2>/dev/null)
+                echo -e "${MAGENTA}${BOLD}╔══ CLASP Session ══╗${NC}"
+                echo -e "${MAGENTA}│ Session:${NC} ${SESSION:0:8}..."
+                echo -e "${MAGENTA}│ Model:${NC} $MODEL"
+                echo -e "${MAGENTA}│ Version:${NC} $VERSION"
+                echo -e "${MAGENTA}│ Tools:${NC} $TOOL_COUNT available"
+                echo -e "${MAGENTA}│ MCP:${NC} $MCP_SERVERS"
+                echo -e "${MAGENTA}╚════════════════════╝${NC}"
+            else
+                MSG=$(echo "$line" | jq -r '.message // empty' 2>/dev/null)
+                if [ -n "$MSG" ]; then
+                    echo -e "${GRAY}[system] $MSG${NC}"
+                fi
+            fi
+            ;;
+
+        "assistant")
+            # Assistant messages - can contain text or tool_use in content array
+            CONTENT_TYPE=$(echo "$line" | jq -r '.message.content[0].type // empty' 2>/dev/null)
+
+            case "$CONTENT_TYPE" in
+                "text")
+                    TEXT=$(echo "$line" | jq -r '.message.content[0].text // empty' 2>/dev/null)
+                    if [ -n "$TEXT" ] && [ "$TEXT" != "null" ]; then
+                        echo ""
+                        echo -e "${WHITE}${BOLD}Claude:${NC}"
+                        echo "$TEXT" | while IFS= read -r text_line; do
+                            echo -e "${WHITE}  $text_line${NC}"
+                        done
+                    fi
+                    ;;
+                "tool_use")
+                    # Tool call from assistant
+                    TOOL_NAME=$(echo "$line" | jq -r '.message.content[0].name // empty' 2>/dev/null)
+                    TOOL_ID=$(echo "$line" | jq -r '.message.content[0].id // empty' 2>/dev/null)
+                    TOOL_INPUT=$(echo "$line" | jq -r '.message.content[0].input // {}' 2>/dev/null)
+
+                    echo ""
+
+                    # Format tool-specific output
+                    case "$TOOL_NAME" in
+                        "Bash")
+                            CMD=$(echo "$TOOL_INPUT" | jq -r '.command // empty' 2>/dev/null)
+                            DESC=$(echo "$TOOL_INPUT" | jq -r '.description // empty' 2>/dev/null)
+                            echo -e "${CYAN}${BOLD}▶ Bash:${NC} ${WHITE}$CMD${NC}"
+                            if [ -n "$DESC" ] && [ "$DESC" != "null" ]; then
+                                echo -e "${GRAY}  └─ $DESC${NC}"
+                            fi
+                            ;;
+                        "Read")
+                            FILE=$(echo "$TOOL_INPUT" | jq -r '.file_path // empty' 2>/dev/null)
+                            echo -e "${CYAN}${BOLD}▶ Read:${NC} ${WHITE}$FILE${NC}"
+                            ;;
+                        "Write")
+                            FILE=$(echo "$TOOL_INPUT" | jq -r '.file_path // empty' 2>/dev/null)
+                            CONTENT=$(echo "$TOOL_INPUT" | jq -r '.content // empty' 2>/dev/null)
+                            LINES=$(echo "$CONTENT" | wc -l)
+                            echo -e "${CYAN}${BOLD}▶ Write:${NC} ${WHITE}$FILE${NC} ${GRAY}($LINES lines)${NC}"
+                            ;;
+                        "Edit")
+                            FILE=$(echo "$TOOL_INPUT" | jq -r '.file_path // empty' 2>/dev/null)
+                            OLD=$(echo "$TOOL_INPUT" | jq -r '.old_string // empty' 2>/dev/null | head -1)
+                            echo -e "${CYAN}${BOLD}▶ Edit:${NC} ${WHITE}$FILE${NC}"
+                            if [ -n "$OLD" ]; then
+                                echo -e "${GRAY}  └─ replacing: \"${OLD:0:60}...\"${NC}"
+                            fi
+                            ;;
+                        "Glob")
+                            PATTERN=$(echo "$TOOL_INPUT" | jq -r '.pattern // empty' 2>/dev/null)
+                            echo -e "${CYAN}${BOLD}▶ Glob:${NC} ${WHITE}$PATTERN${NC}"
+                            ;;
+                        "Grep")
+                            PATTERN=$(echo "$TOOL_INPUT" | jq -r '.pattern // empty' 2>/dev/null)
+                            PATH_ARG=$(echo "$TOOL_INPUT" | jq -r '.path // empty' 2>/dev/null)
+                            echo -e "${CYAN}${BOLD}▶ Grep:${NC} ${WHITE}$PATTERN${NC}"
+                            if [ -n "$PATH_ARG" ] && [ "$PATH_ARG" != "null" ]; then
+                                echo -e "${GRAY}  └─ in: $PATH_ARG${NC}"
+                            fi
+                            ;;
+                        "TodoWrite")
+                            TODO_COUNT=$(echo "$TOOL_INPUT" | jq -r '.todos | length // 0' 2>/dev/null)
+                            echo -e "${CYAN}${BOLD}▶ TodoWrite:${NC} ${WHITE}$TODO_COUNT items${NC}"
+                            echo "$TOOL_INPUT" | jq -r '.todos[]? | "  " + (if .status == "completed" then "✅" elif .status == "in_progress" then "🔄" else "⏳" end) + " " + .content' 2>/dev/null | head -8
+                            ;;
+                        "Task")
+                            DESC=$(echo "$TOOL_INPUT" | jq -r '.description // empty' 2>/dev/null)
+                            AGENT=$(echo "$TOOL_INPUT" | jq -r '.subagent_type // empty' 2>/dev/null)
+                            echo -e "${CYAN}${BOLD}▶ Task:${NC} ${WHITE}$DESC${NC}"
+                            if [ -n "$AGENT" ] && [ "$AGENT" != "null" ]; then
+                                echo -e "${GRAY}  └─ agent: $AGENT${NC}"
+                            fi
+                            ;;
+                        *)
+                            # Default: show tool name and formatted JSON
+                            echo -e "${CYAN}${BOLD}▶ Tool: $TOOL_NAME${NC}"
+                            if [ -n "$TOOL_INPUT" ] && [ "$TOOL_INPUT" != "{}" ]; then
+                                echo -e "${GRAY}┌─ Input ─────────────────────────────────────────${NC}"
+                                echo "$TOOL_INPUT" | jq -r '.' 2>/dev/null | while IFS= read -r input_line; do
+                                    echo -e "${GRAY}│ $input_line${NC}"
+                                done
+                                echo -e "${GRAY}└─────────────────────────────────────────────────${NC}"
+                            fi
+                            ;;
+                    esac
+                    ;;
+            esac
+            ;;
+
+        "user")
+            # User messages - usually tool results
+            TOOL_RESULT_TYPE=$(echo "$line" | jq -r '.message.content[0].type // empty' 2>/dev/null)
+            if [ "$TOOL_RESULT_TYPE" = "tool_result" ]; then
+                TOOL_ID=$(echo "$line" | jq -r '.message.content[0].tool_use_id // empty' 2>/dev/null)
+                IS_ERROR=$(echo "$line" | jq -r '.message.content[0].is_error // false' 2>/dev/null)
+                CONTENT=$(echo "$line" | jq -r '.message.content[0].content // empty' 2>/dev/null)
+
+                RESULT_TYPE=$(echo "$line" | jq -r '.tool_use_result.type // empty' 2>/dev/null)
+
+                if [ "$IS_ERROR" = "true" ]; then
+                    echo -e "${RED}${BOLD}✗ Error:${NC}"
+                    echo -e "${RED}┌─ Error Output ──────────────────────────────────${NC}"
+                    echo "$CONTENT" | while IFS= read -r result_line; do
+                        echo -e "${RED}│ $result_line${NC}"
+                    done
+                    echo -e "${RED}└─────────────────────────────────────────────────${NC}"
+                elif [ "$RESULT_TYPE" = "text" ]; then
+                    FILE_PATH=$(echo "$line" | jq -r '.tool_use_result.file.filePath // empty' 2>/dev/null)
+                    NUM_LINES=$(echo "$line" | jq -r '.tool_use_result.file.numLines // empty' 2>/dev/null)
+                    echo -e "${GREEN}${BOLD}✓ Read: ${FILE_PATH}${NC} ${GRAY}(${NUM_LINES} lines)${NC}"
+                elif [ "$RESULT_TYPE" = "create" ]; then
+                    FILE_PATH=$(echo "$line" | jq -r '.tool_use_result.filePath // empty' 2>/dev/null)
+                    echo -e "${GREEN}${BOLD}✓ Created: ${FILE_PATH}${NC}"
+                elif [ "$RESULT_TYPE" = "edit" ] || [ "$RESULT_TYPE" = "replace" ]; then
+                    FILE_PATH=$(echo "$line" | jq -r '.tool_use_result.filePath // empty' 2>/dev/null)
+                    echo -e "${GREEN}${BOLD}✓ Edited: ${FILE_PATH}${NC}"
+                else
+                    STDOUT=$(echo "$line" | jq -r '.tool_use_result.stdout // empty' 2>/dev/null)
+                    OUTPUT="${STDOUT:-$CONTENT}"
+
+                    if [ -n "$OUTPUT" ]; then
+                        LINE_COUNT=$(echo "$OUTPUT" | wc -l)
+                        echo -e "${GREEN}${BOLD}✓ Result:${NC} ${GRAY}($LINE_COUNT lines)${NC}"
+                        # Show abbreviated output
+                        echo "$OUTPUT" | head -5 | while IFS= read -r result_line; do
+                            echo -e "${GRAY}  $result_line${NC}"
+                        done
+                        if [ $LINE_COUNT -gt 5 ]; then
+                            echo -e "${GRAY}  ... ($((LINE_COUNT - 5)) more lines)${NC}"
+                        fi
+                    fi
+                fi
+            fi
+            ;;
+
+        "content_block_start")
+            BLOCK_TYPE=$(echo "$line" | jq -r '.content_block.type // empty' 2>/dev/null)
+            case "$BLOCK_TYPE" in
+                "tool_use")
+                    TOOL_NAME=$(echo "$line" | jq -r '.content_block.name // empty' 2>/dev/null)
+                    CURRENT_TOOL="$TOOL_NAME"
+                    echo -e "\n${CYAN}${BOLD}▶ Tool: $TOOL_NAME${NC}"
+                    ;;
+                "thinking")
+                    IN_THINKING=true
+                    echo -e "\n${MAGENTA}${DIM}💭 Thinking...${NC}"
+                    ;;
+            esac
+            ;;
+
+        "content_block_delta")
+            DELTA_TYPE=$(echo "$line" | jq -r '.delta.type // empty' 2>/dev/null)
+            case "$DELTA_TYPE" in
+                "text_delta")
+                    TEXT=$(echo "$line" | jq -r '.delta.text // empty' 2>/dev/null)
+                    if [ -n "$TEXT" ]; then
+                        if [ "$IN_THINKING" = true ]; then
+                            echo -ne "${MAGENTA}${DIM}$TEXT${NC}"
+                        else
+                            echo -ne "${WHITE}$TEXT${NC}"
+                        fi
+                    fi
+                    ;;
+                "input_json_delta")
+                    JSON=$(echo "$line" | jq -r '.delta.partial_json // empty' 2>/dev/null)
+                    if [ -n "$JSON" ]; then
+                        echo -ne "${GRAY}$JSON${NC}"
+                    fi
+                    ;;
+            esac
+            ;;
+
+        "content_block_stop")
+            if [ "$IN_THINKING" = true ]; then
+                IN_THINKING=false
+                echo -e "\n${MAGENTA}${DIM}💭 Done thinking${NC}"
+            fi
+            echo ""
+            ;;
+
+        "result")
+            # Final result
+            echo -e "\n${GREEN}${BOLD}═══════════════════════════════════════════════════${NC}"
+            echo -e "${GREEN}${BOLD}                    RESULT                         ${NC}"
+            echo -e "${GREEN}${BOLD}═══════════════════════════════════════════════════${NC}"
+
+            RESULT=$(echo "$line" | jq -r '.result // empty' 2>/dev/null)
+            if [ -n "$RESULT" ]; then
+                echo "$RESULT" | while IFS= read -r result_line; do
+                    echo -e "${WHITE}$result_line${NC}"
+                done
+            fi
+
+            # Show cost and tokens
+            COST=$(echo "$line" | jq -r '.cost_usd // empty' 2>/dev/null)
+            INPUT_TOKENS=$(echo "$line" | jq -r '.usage.input_tokens // empty' 2>/dev/null)
+            OUTPUT_TOKENS=$(echo "$line" | jq -r '.usage.output_tokens // empty' 2>/dev/null)
+            DURATION=$(echo "$line" | jq -r '.duration_ms // empty' 2>/dev/null)
+
+            echo ""
+            echo -e "${GRAY}───────────────────────────────────────────────────${NC}"
+            [ -n "$COST" ] && [ "$COST" != "null" ] && echo -e "${GRAY}💰 Cost: \$$COST${NC}"
+            [ -n "$INPUT_TOKENS" ] && [ "$INPUT_TOKENS" != "null" ] && echo -e "${GRAY}📥 Input: $INPUT_TOKENS tokens${NC}"
+            [ -n "$OUTPUT_TOKENS" ] && [ "$OUTPUT_TOKENS" != "null" ] && echo -e "${GRAY}📤 Output: $OUTPUT_TOKENS tokens${NC}"
+            [ -n "$DURATION" ] && [ "$DURATION" != "null" ] && echo -e "${GRAY}⏱️  Duration: ${DURATION}ms${NC}"
+            echo -e "${GRAY}───────────────────────────────────────────────────${NC}"
+            ;;
+
+        "error")
+            ERROR=$(echo "$line" | jq -r '.error.message // .message // empty' 2>/dev/null)
+            echo -e "\n${RED}${BOLD}╔══ ERROR ══════════════════════════════════════════╗${NC}"
+            echo -e "${RED}${BOLD}║ $ERROR${NC}"
+            echo -e "${RED}${BOLD}╚═══════════════════════════════════════════════════╝${NC}"
+            ;;
+
+        "message_start"|"message_delta"|"message_stop")
+            # Message lifecycle events - ignore silently
+            ;;
+
+        *)
+            # Handle custom events (iteration markers, etc)
+            EVENT=$(echo "$line" | jq -r '.event // empty' 2>/dev/null)
+            if [ -n "$EVENT" ]; then
+                case "$EVENT" in
+                    "iteration_start")
+                        ITER=$(echo "$line" | jq -r '.iteration // empty' 2>/dev/null)
+                        TS=$(echo "$line" | jq -r '.timestamp // empty' 2>/dev/null)
+                        echo -e "${YELLOW}${BOLD}🔄 Iteration $ITER started at $TS${NC}"
+                        ;;
+                    "iteration_end")
+                        ITER=$(echo "$line" | jq -r '.iteration // empty' 2>/dev/null)
+                        DUR=$(echo "$line" | jq -r '.duration_secs // empty' 2>/dev/null)
+                        echo -e "${YELLOW}${BOLD}✅ Iteration $ITER ended (${DUR}s)${NC}"
+                        ;;
+                esac
+            fi
+            ;;
+    esac
+done

package/.claude-flow/metrics/agent-metrics.json

@@ -1 +0,0 @@
-{}

package/.claude-flow/metrics/performance.json

@@ -1,87 +0,0 @@
-{
-  "startTime": 1764962870165,
-  "sessionId": "session-1764962870165",
-  "lastActivity": 1764962870165,
-  "sessionDuration": 0,
-  "totalTasks": 1,
-  "successfulTasks": 1,
-  "failedTasks": 0,
-  "totalAgents": 0,
-  "activeAgents": 0,
-  "neuralEvents": 0,
-  "memoryMode": {
-    "reasoningbankOperations": 0,
-    "basicOperations": 0,
-    "autoModeSelections": 0,
-    "modeOverrides": 0,
-    "currentMode": "auto"
-  },
-  "operations": {
-    "store": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "retrieve": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "query": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "list": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "delete": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "search": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    },
-    "init": {
-      "count": 0,
-      "totalDuration": 0,
-      "errors": 0
-    }
-  },
-  "performance": {
-    "avgOperationDuration": 0,
-    "minOperationDuration": null,
-    "maxOperationDuration": null,
-    "slowOperations": 0,
-    "fastOperations": 0,
-    "totalOperationTime": 0
-  },
-  "storage": {
-    "totalEntries": 0,
-    "reasoningbankEntries": 0,
-    "basicEntries": 0,
-    "databaseSize": 0,
-    "lastBackup": null,
-    "growthRate": 0
-  },
-  "errors": {
-    "total": 0,
-    "byType": {},
-    "byOperation": {},
-    "recent": []
-  },
-  "reasoningbank": {
-    "semanticSearches": 0,
-    "sqlFallbacks": 0,
-    "embeddingGenerated": 0,
-    "consolidations": 0,
-    "avgQueryTime": 0,
-    "cacheHits": 0,
-    "cacheMisses": 0
-  }
-}

package/.claude-flow/metrics/task-metrics.json

@@ -1,10 +0,0 @@
-[
-  {
-    "id": "cmd-hooks-1764962870434",
-    "type": "hooks",
-    "success": true,
-    "duration": 67.44506799999999,
-    "timestamp": 1764962870501,
-    "metadata": {}
-  }
-]

package/bin/clasp

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-console.log(`
-   _____ _        _    ____  ____  
-  / ____| |      / \\  / ___||  _ \\ 
- | |    | |     / _ \\ \\___ \\| |_) |
- | |    | |___ / ___ \\ ___) |  __/ 
-  \\_____|_____/_/   \\_\\____/|_|    
-
-  Claude Language Agent Super Proxy
-  
-  Version: 0.0.1 (placeholder)
-  
-  Full implementation coming soon!
-  
-  This will allow you to run Claude Code with:
-  - OpenAI (direct)
-  - Azure OpenAI
-  - OpenRouter (200+ models)
-  - Any OpenAI-compatible endpoint (Ollama, vLLM, etc.)
-  
-  GitHub: https://github.com/yourname/clasp-ai
-`);

package/postinstall.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-// Placeholder postinstall script
-// Will download platform-specific Go binary in the full release
-console.log('clasp-ai installed successfully!');