@looplia/looplia-cli 0.7.3 → 0.7.5

package/plugins/looplia-core/hooks/hooks.json

@@ -1,22 +0,0 @@
-{
-  "$schema": "https://code.claude.com/schemas/hooks.json",
-  "hooks": [
-    {
-      "event": "PostToolUse",
-      "matcher": "Write",
-      "command": "./scripts/hooks/post-write-validate.sh",
-      "description": "Auto-validate artifacts written to sandbox outputs"
-    },
-    {
-      "event": "Stop",
-      "command": "./scripts/hooks/stop-guard.sh",
-      "description": "Guard workflow completion - block until all validated"
-    },
-    {
-      "event": "SessionStart",
-      "matcher": "compact",
-      "command": "./scripts/hooks/compact-inject-state.sh",
-      "description": "Re-inject sandbox state after context compact"
-    }
-  ]
-}

package/plugins/looplia-core/scripts/hooks/compact-inject-state.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-# Context Compact State Injection Hook (v0.6.0)
-# Triggered: When context is compacted (SessionStart:compact)
-# Action: Re-inject current sandbox progress into new context
-
-set -euo pipefail
-
-# Find active sandbox
-SANDBOX_BASE="${HOME}/.looplia/sandbox"
-if [[ ! -d "$SANDBOX_BASE" ]]; then
-  exit 0
-fi
-
-# Sort by modification time (newest first) to get most recent sandbox
-SANDBOX_DIR=$(ls -td "$SANDBOX_BASE"/*/ 2>/dev/null | head -1 | sed 's:/$::')
-if [[ -z "$SANDBOX_DIR" ]]; then
-  exit 0
-fi
-
-VALIDATION_JSON="$SANDBOX_DIR/validation.json"
-SANDBOX_ID=$(basename "$SANDBOX_DIR")
-
-if [[ ! -f "$VALIDATION_JSON" ]]; then
-  exit 0
-fi
-
-WORKFLOW=$(jq -r '.workflow // "unknown"' "$VALIDATION_JSON")
-
-# Build progress summary (v0.6.0 uses "steps" not "outputs")
-echo "=== Active Sandbox: $SANDBOX_ID ==="
-echo "Workflow: $WORKFLOW"
-echo ""
-echo "Progress:"
-jq -r '.steps | to_entries[] | "  - \(.key): \(if .value.validated then "✓ validated" else "⏳ pending" end)"' "$VALIDATION_JSON"
-echo ""
-echo "Next: Complete pending steps in dependency order."

package/plugins/looplia-core/scripts/hooks/post-write-validate.sh

@@ -1,81 +0,0 @@
-#!/bin/bash
-# Post-Write Artifact Validator Hook (v0.6.0)
-# Triggered: When Write tool completes
-# Action: Run semantic validation via validate.ts for sandbox outputs
-
-set -euo pipefail
-
-# Read JSON input from stdin
-INPUT=$(cat)
-FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
-
-# Only process sandbox/ files (matches sandbox/{id}/outputs/*.json pattern)
-if [[ "$FILE_PATH" != *"/sandbox/"* ]]; then
-  exit 0
-fi
-
-# Check if it's in outputs/ directory
-if [[ "$FILE_PATH" != *"/outputs/"* ]]; then
-  exit 0
-fi
-
-# Extract sandbox directory and artifact name
-SANDBOX_DIR=$(dirname "$(dirname "$FILE_PATH")")
-ARTIFACT=$(basename "$FILE_PATH" .json)
-VALIDATION_JSON="$SANDBOX_DIR/validation.json"
-
-# Check for validation.json
-if [[ ! -f "$VALIDATION_JSON" ]]; then
-  exit 0
-fi
-
-# Use file locking to prevent race conditions when multiple writes happen concurrently
-# flock ensures exclusive access to validation.json during read-modify-write cycle
-LOCK_FILE="${VALIDATION_JSON}.lock"
-
-(
-  # Acquire exclusive lock (wait up to 30 seconds)
-  if ! flock -x -w 30 200; then
-    echo "Failed to acquire lock on validation.json" >&2
-    exit 1
-  fi
-
-  # Get validation criteria from validation.json (v0.6.0 uses "steps" not "outputs")
-  CRITERIA=$(jq -r --arg art "$ARTIFACT" '.steps[$art].validate // empty' "$VALIDATION_JSON" 2>/dev/null)
-
-  if [[ -z "$CRITERIA" || "$CRITERIA" == "null" ]]; then
-    # No criteria defined - just check JSON validity
-    if ! jq empty "$FILE_PATH" 2>/dev/null; then
-      echo "Validation failed for $ARTIFACT: Invalid JSON" >&2
-      exit 2
-    fi
-  else
-    # Run full semantic validation via validate.ts
-    SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-    VALIDATOR_SCRIPT="$SCRIPT_DIR/../../skills/workflow-validator/scripts/validate.ts"
-
-    if [[ -f "$VALIDATOR_SCRIPT" ]]; then
-      # Run the validation script
-      RESULT=$(bun "$VALIDATOR_SCRIPT" "$FILE_PATH" "$CRITERIA" 2>&1) || true
-      PASSED=$(echo "$RESULT" | jq -r '.passed // false' 2>/dev/null) || PASSED="false"
-
-      if [[ "$PASSED" != "true" ]]; then
-        echo "Semantic validation failed for $ARTIFACT:" >&2
-        echo "$RESULT" >&2
-        exit 2
-      fi
-    else
-      # Fallback to basic JSON check if validator script not found
-      if ! jq empty "$FILE_PATH" 2>/dev/null; then
-        echo "Validation failed for $ARTIFACT: Invalid JSON" >&2
-        exit 2
-      fi
-    fi
-  fi
-
-  # Update validation.json to mark step as validated (v0.6.0 uses "steps")
-  jq --arg art "$ARTIFACT" '.steps[$art].validated = true' "$VALIDATION_JSON" > "${VALIDATION_JSON}.tmp"
-  mv "${VALIDATION_JSON}.tmp" "$VALIDATION_JSON"
-  echo "✓ Validated: $ARTIFACT.json" >&2
-
-) 200>"$LOCK_FILE"

package/plugins/looplia-core/scripts/hooks/stop-guard.sh

@@ -1,56 +0,0 @@
-#!/bin/bash
-# Workflow Completion Guard Hook (v0.6.1)
-# Triggered: When main agent attempts to stop
-# Action: Block if any step has validated: false OR output files missing
-
-set -euo pipefail
-
-INPUT=$(cat)
-STOP_HOOK_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
-
-# Prevent infinite loop
-if [[ "$STOP_HOOK_ACTIVE" == "true" ]]; then
-  exit 0
-fi
-
-# Find active sandbox (most recently modified sandbox directory)
-SANDBOX_BASE="${HOME}/.looplia/sandbox"
-if [[ ! -d "$SANDBOX_BASE" ]]; then
-  exit 0
-fi
-
-# Sort by modification time (newest first) to get most recent sandbox
-SANDBOX_DIR=$(ls -td "$SANDBOX_BASE"/*/ 2>/dev/null | head -1 | sed 's:/$::')
-if [[ -z "$SANDBOX_DIR" ]]; then
-  exit 0
-fi
-
-VALIDATION_JSON="$SANDBOX_DIR/validation.json"
-if [[ ! -f "$VALIDATION_JSON" ]]; then
-  exit 0
-fi
-
-# Check for missing output files first (more actionable feedback)
-MISSING=""
-for step in $(jq -r '.steps | keys[]' "$VALIDATION_JSON" 2>/dev/null); do
-  OUTPUT_PATH=$(jq -r --arg s "$step" '.steps[$s].output // empty' "$VALIDATION_JSON" 2>/dev/null)
-  if [[ -n "$OUTPUT_PATH" && ! -f "$OUTPUT_PATH" ]]; then
-    MISSING="$MISSING $step"
-  fi
-done
-
-if [[ -n "$MISSING" ]]; then
-  echo "{\"decision\": \"block\", \"reason\": \"Missing output files for steps:$MISSING. You MUST call the Write tool to create these files at the paths specified in the workflow.\"}"
-  exit 0
-fi
-
-# Check all steps are validated (v0.6.0 uses "steps" not "outputs")
-PENDING=$(jq -r '.steps | to_entries[] | select(.value.validated == false) | .key' "$VALIDATION_JSON" 2>/dev/null | tr '\n' ', ' | sed 's/,$//')
-
-if [[ -n "$PENDING" ]]; then
-  echo "{\"decision\": \"block\", \"reason\": \"Workflow incomplete. Pending validation for steps: $PENDING. Output files exist but need validation - re-write them to trigger validation.\"}"
-  exit 0
-fi
-
-# All validated - allow stop
-exit 0

package/plugins/looplia-core/skills/workflow-executor-inline/SKILL.md

@@ -1,217 +0,0 @@
----
-name: workflow-executor-inline
-description: |
-  Inline workflow executor for proxy providers (ZenMux, custom API providers).
-  Executes workflow steps directly in the main context WITHOUT spawning Task subagents.
-
-  Use this skill when:
-  - Running looplia workflows via ZenMux or other proxy providers
-  - Task subagents fail with "invalid_model" errors
-  - You need inline execution without context isolation
-
-  Architecture: Each workflow step is executed INLINE (no Task tool) - read skill, execute
-  mission, write output, then proceed to next step. All steps share the main context.
-
-  v0.6.6: Created for cross-provider compatibility with ZenMux.
----
-
-# Workflow Executor Inline (v0.6.6)
-
-Execute looplia workflows **without Task subagents**. This skill is specifically designed for proxy providers (ZenMux, custom) where the Claude Agent SDK's subagent spawning doesn't work due to model name incompatibility.
-
-## When to Use
-
-Use this skill when:
-- The system has injected a hint to use inline execution
-- Running workflows via ZenMux or other proxy providers
-- Task subagents fail with "invalid_model" errors
-
-## CRITICAL: Inline Execution (No Subagents)
-
-**DO NOT spawn Task subagents.** Execute all workflow steps directly in the main context.
-
-For each workflow step:
-
-1. **Read the skill definition** using Skill tool: `Skill("{step.skill}")`
-2. **Read input file(s)** if specified using Read tool
-3. **Execute the mission** following skill instructions
-4. **Write JSON output** to specified path using Write tool
-5. **Validate output** (if validation rules defined)
-6. **Proceed to next step**
-
----
-
-## Execution Protocol
-
-### Phase 1: Sandbox Setup
-
-Same as standard workflow-executor:
-
-1. Generate sandbox ID:
-   ```
-   {first-input-name}-{YYYY-MM-DD}-{random4chars}
-   Example: video-transcript-2025-12-18-xk7m
-   ```
-
-2. Create folder structure:
-   ```
-   sandbox/{sandbox-id}/
-   ├── inputs/
-   │   └── {input-files}.md
-   ├── outputs/
-   ├── logs/
-   └── validation.json
-   ```
-
-3. Copy input files to `inputs/`
-
-### Phase 2: Workflow Parsing
-
-1. Read workflow file: `workflows/{workflow-id}.md`
-2. Parse YAML frontmatter for steps
-3. Validate each step has `skill:` and `mission:` fields
-4. Build dependency graph from `needs:` fields
-
-### Phase 3: Inline Step Execution
-
-**Execute steps ONE AT A TIME, INLINE (no Task tool):**
-
-```
-FOR EACH step in dependency order:
-    │
-    ▼
-┌─────────────────────────────────────────┐
-│ 1. INVOKE skill: Skill("{step.skill}")  │
-│    → This loads skill context           │
-│                                         │
-│ 2. READ input file (if provided)        │
-│    → Use Read tool                      │
-│                                         │
-│ 3. EXECUTE mission                      │
-│    → Follow skill instructions          │
-│    → Generate JSON output               │
-│                                         │
-│ 4. WRITE output file                    │
-│    → Use Write tool                     │
-│    → Output to step.output path         │
-│                                         │
-│ 5. VALIDATE output                      │
-│    → Check required_fields              │
-│    → Retry if failed (max 2x)           │
-│                                         │
-│ 6. UPDATE validation.json               │
-│    → Mark step as validated: true       │
-└─────────────────────────────────────────┘
-         │
-         ▼
-    NEXT STEP
-```
-
-### Example: Inline Execution
-
-For step:
-```yaml
-- id: analyze-content
-  skill: media-reviewer
-  mission: |
-    Deep analysis of video transcript. Extract key themes,
-    important quotes, and narrative structure.
-  input: ${{ sandbox }}/inputs/content.md
-  output: ${{ sandbox }}/outputs/analysis.json
-  validate:
-    required_fields: [contentId, headline, keyThemes]
-```
-
-**Inline execution sequence:**
-
-1. **Invoke skill:**
-   ```
-   Skill("media-reviewer")
-   ```
-
-2. **Read input:**
-   ```
-   Read("sandbox/video-2025-12-18-xk7m/inputs/content.md")
-   ```
-
-3. **Execute mission:**
-   - Follow media-reviewer skill instructions
-   - Analyze the content
-   - Generate structured JSON output
-
-4. **Write output:**
-   ```
-   Write("sandbox/video-2025-12-18-xk7m/outputs/analysis.json", jsonContent)
-   ```
-
-5. **Validate:**
-   - Check contentId, headline, keyThemes exist
-   - Update validation.json
-
-6. **Proceed to next step**
-
----
-
-## Anti-Patterns
-
-❌ **WRONG - Spawning Task subagents:**
-```json
-{
-  "subagent_type": "workflow-step",
-  "description": "Execute step...",
-  "prompt": "..."
-}
-```
-Task subagents don't work with proxy providers.
-
-❌ **WRONG - Batching all steps:**
-Execute all steps at once without validation between them.
-
-✅ **CORRECT - Inline step-by-step:**
-1. Skill("media-reviewer")
-2. Read input
-3. Execute mission
-4. Write output
-5. Validate
-6. Proceed to next
-
----
-
-## Variable Substitution
-
-Same as standard workflow-executor:
-
-| Variable | Resolution |
-|----------|------------|
-| `${{ sandbox }}` | `sandbox/{sandbox-id}` |
-| `${{ inputs.{name} }}` | `sandbox/{id}/inputs/{name}.md` |
-| `${{ steps.{id}.output }}` | Output path of step `{id}` |
-
----
-
-## Error Handling
-
-| Scenario | Action |
-|----------|--------|
-| Workflow not found | Error with available workflows |
-| Step missing `skill:` | Error: "Step missing required 'skill' field" |
-| Step missing `mission:` | Error: "Step missing required 'mission' field" |
-| Validation fails | Retry inline with feedback (max 2 retries) |
-| Max retries exceeded | Report failure with details |
-
----
-
-## Key Differences from Standard workflow-executor
-
-| Aspect | workflow-executor | workflow-executor-inline |
-|--------|------------------|--------------------------|
-| Execution | Task subagent per step | Inline in main context |
-| Context | Isolated per step | Shared main context |
-| Provider Support | Anthropic Direct only | All providers |
-| Use Case | Production (Anthropic) | Proxy providers (ZenMux) |
-
----
-
-## Version History
-
-- **v0.6.6**: Created for ZenMux cross-provider compatibility