claude-flow-novice 2.18.6 → 2.18.7

package/claude-assets/skills/cfn-memory-persistence/lib/sqlite/QUICK_REFERENCE.md

@@ -1,204 +0,0 @@
-# SQLite Memory CLI - Quick Reference Card
-
-**Status:** OPERATIONAL | **Version:** 1.3.0 | **Location:** `.claude/skills/sqlite-memory/memory-cli.sh`
-
----
-
-## Quick Commands
-
-```bash
-# Store agent state
-./memory-cli.sh set --key "agent/$AGENT_ID/state" --value '{"progress":50}' --acl 1
-
-# Retrieve agent state
-./memory-cli.sh get --key "agent/$AGENT_ID/state"
-
-# Delete agent state
-./memory-cli.sh delete --key "agent/$AGENT_ID/state"
-
-# Store swarm coordination data
-./memory-cli.sh set --key "swarm/phase-1/status" --value '{"complete":true}' --acl 3
-
-# Get swarm status
-./memory-cli.sh get --key "swarm/phase-1/status"
-```
-
----
-
-## ACL Levels (Quick Reference)
-
-| Level | Name | Use For |
-|-------|------|---------|
-| 1 | AGENT | Private agent state |
-| 2 | TEAM | Team coordination |
-| 3 | SWARM | Swarm coordination |
-| 4 | PROJECT | Project-wide data |
-| 5 | SYSTEM | System operations |
-
----
-
-## Common Patterns
-
-### Pattern 1: Persistent Agent State
-```bash
-# Get previous state (or null if new)
-STATE=$(./memory-cli.sh get --key "agent/$AGENT_ID/state" | jq -r '.value')
-
-# Update and store
-./memory-cli.sh set --key "agent/$AGENT_ID/state" --value "$NEW_STATE" --acl 1
-```
-
-### Pattern 2: Swarm Phase Tracking
-```bash
-# Check if phase complete
-COMPLETE=$(./memory-cli.sh get --key "swarm/$PHASE_ID/status" | jq -r '.value.complete')
-
-if [ "$COMPLETE" != "true" ]; then
-  # Mark as complete
-  ./memory-cli.sh set --key "swarm/$PHASE_ID/status" --value '{"complete":true}' --acl 3
-fi
-```
-
-### Pattern 3: Team Context Sharing
-```bash
-# Share context with team
-./memory-cli.sh set --key "team/$TEAM_ID/context" --value "$CONTEXT_JSON" --acl 2
-
-# Read team context
-CONTEXT=$(./memory-cli.sh get --key "team/$TEAM_ID/context" | jq -r '.value')
-```
-
----
-
-## Parsing JSON Output
-
-All commands return JSON. Use `jq` to parse:
-
-```bash
-# Get value only
-VALUE=$(./memory-cli.sh get --key "key" | jq -r '.value')
-
-# Check success
-SUCCESS=$(./memory-cli.sh set --key "key" --value "val" --acl 1 | jq -r '.success')
-
-# Get specific field from value
-PROGRESS=$(./memory-cli.sh get --key "agent/$AGENT_ID/state" | jq -r '.value.progress')
-```
-
----
-
-## Error Handling
-
-```bash
-# Check if operation succeeded
-RESULT=$(./memory-cli.sh get --key "key")
-SUCCESS=$(echo "$RESULT" | jq -r '.success')
-
-if [ "$SUCCESS" = "true" ]; then
-  VALUE=$(echo "$RESULT" | jq -r '.value')
-  echo "Retrieved: $VALUE"
-else
-  ERROR=$(echo "$RESULT" | jq -r '.error')
-  echo "Error: $ERROR"
-fi
-```
-
----
-
-## Key Naming Conventions
-
-Use hierarchical keys for organization:
-
-```
-agent/<agent-id>/<property>     # Agent-specific data
-team/<team-id>/<property>       # Team-shared data
-swarm/<swarm-id>/<property>     # Swarm coordination
-project/<property>              # Project-wide data
-system/<property>               # System-level data
-```
-
-**Examples:**
-- `agent/worker-1/state`
-- `agent/worker-1/progress`
-- `team/alpha/context`
-- `swarm/phase-1/status`
-- `project/config`
-- `system/backup_info`
-
----
-
-## Common Operations
-
-### Store Complex JSON
-```bash
-./memory-cli.sh set --key "agent/$AGENT_ID/state" \
-  --value '{"progress":75,"status":"working","lastUpdate":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"}' \
-  --acl 1
-```
-
-### Increment a Counter
-```bash
-# Get current count
-COUNT=$(./memory-cli.sh get --key "swarm/counter" | jq -r '.value.count // 0')
-
-# Increment
-NEW_COUNT=$((COUNT + 1))
-
-# Store
-./memory-cli.sh set --key "swarm/counter" --value "{\"count\":$NEW_COUNT}" --acl 3
-```
-
-### Update Nested Value
-```bash
-# Get current state
-STATE=$(./memory-cli.sh get --key "agent/$AGENT_ID/state" | jq -r '.value')
-
-# Update nested field
-UPDATED=$(echo "$STATE" | jq '.metadata.lastCheck = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"')
-
-# Store updated state
-./memory-cli.sh set --key "agent/$AGENT_ID/state" --value "$UPDATED" --acl 1
-```
-
----
-
-## Tips & Best Practices
-
-1. **Always check success:** Parse `.success` field before using `.value`
-2. **Use appropriate ACL:** Match ACL level to data sensitivity
-3. **Use hierarchical keys:** Organize keys with `/` separators
-4. **Store timestamps:** Include `lastUpdate` or `timestamp` fields
-5. **Handle missing keys:** Use `jq -r '.value // null'` for defaults
-6. **Clean up old data:** Delete temporary keys when done
-
----
-
-## Troubleshooting
-
-**Issue:** "Key not found"
-```bash
-# Solution: Check if key exists and handle null case
-VALUE=$(./memory-cli.sh get --key "key" | jq -r '.value // "default"')
-```
-
-**Issue:** CLI not found
-```bash
-# Solution: Build project first
-cd /path/to/project && npm run build
-```
-
-**Issue:** Permission denied
-```bash
-# Solution: Make script executable
-chmod +x ./.claude/skills/sqlite-memory/memory-cli.sh
-```
-
----
-
-## Full Documentation
-
-See `.claude/skills/sqlite-memory/SKILL.md` for complete documentation.
-
----
-
-**Last Updated:** 2025-10-18 | **Status:** OPERATIONAL

package/claude-assets/skills/cfn-memory-persistence/lib/sqlite/README.md

@@ -1,65 +0,0 @@
-# SQLite Memory Access Skill (Sprint 2.1)
-
-## Status: COMPLETE ✅
-
-**Consensus:** 0.95/1.00  
-**Sprint:** 2.1 - SQLite Memory Access Patterns  
-**Completion:** 2025-10-18T06:07Z
-
-## Deliverables
-
-| File | Lines | Status | Description |
-|------|-------|--------|-------------|
-| SKILL.md | 249 | ✅ | 5-level ACL model, query patterns, Redis+SQLite integration |
-| acl-queries.sql | 451 | ✅ | Pre-built queries for all 5 ACL levels with encryption |
-| ttl-cleanup.sh | 273 | ✅ | Automated TTL expiration with retention policies |
-
-## Acceptance Criteria
-
-- ✅ 5-level ACL model documented (Agent/Team/Swarm/Project/System)
-- ✅ Query patterns for each ACL level with encryption enforcement (AES-256)
-- ✅ Redis hot cache + SQLite cold storage integration
-- ✅ TTL management rules by data type (1h Redis, 30-365d SQLite)
-- ⚠️  Test coverage: Pending implementation (use existing test suite in `src/memory/__tests__/`)
-
-## Usage
-
-### 1. ACL Query Patterns
-```sql
-sqlite3 swarm-memory.db < .claude/skills/sqlite-memory/acl-queries.sql
-```
-
-### 2. TTL Cleanup (Automated)
-```bash
-# Dry run
-DRY_RUN=true ./.claude/skills/sqlite-memory/ttl-cleanup.sh
-
-# Production cleanup
-./.claude/skills/sqlite-memory/ttl-cleanup.sh
-```
-
-### 3. Skill Reference
-See `SKILL.md` for:
-- 5-level ACL architecture
-- Redis+SQLite integration patterns
-- Encryption key management
-- Query examples per ACL level
-
-## Integration with Existing System
-
-This skill complements:
-- `/mnt/c/Users/masha/Documents/claude-flow-novice/src/memory/swarm-memory.ts` (SQLite adapter)
-- `/mnt/c/Users/masha/Documents/claude-flow-novice/src/memory/__tests__/sqlite-memory-adapter.test.js` (existing tests)
-
-## Next Steps
-
-1. Integrate acl-queries.sql into SwarmMemory class
-2. Add ttl-cleanup.sh to cron schedule
-3. Implement test suite for ACL enforcement (100% coverage goal)
-4. Update CLAUDE.md with skill reference
-
----
-
-**Coordinator:** coordinator-hybrid  
-**Agents:** analyst, architect, coder, reviewer  
-**Redis Channel:** swarm:skills:sprint-2.1  

package/claude-assets/skills/cfn-memory-persistence/lib/sqlite/SKILL.md

@@ -1,415 +0,0 @@
----
-name: SQLite Memory Access
-version: 1.3.0
-complexity: High
-keywords: [
-    "multi-tier access",
-    "5-level ACL",
-    "secure data persistence",
-    "encrypted storage",
-    "redis session management",
-    "contextual memory",
-    "TTL expiration",
-    "cli wrapper",
-    "agent-accessible"
-]
-triggers: [
-    "secure memory management",
-    "tiered access control",
-    "contextual data storage",
-    "agent memory operations"
-]
-performance_targets: {
-    "query_time_ms": 20,
-    "encryption_strength_bits": 256,
-    "cache_hit_rate_pct": 85,
-    "max_concurrent_connections": 100
-}
-status: OPERATIONAL
----
-
-# SQLite Memory Access Skill
-
-## Overview
-This skill provides secure SQLite memory access with a 5-level Access Control List (ACL) system, integrating with Redis for session management and caching. The implementation includes encrypted query patterns, TTL-based expiration, comprehensive test coverage, and a CLI wrapper for agent-accessible memory operations.
-
-## Status: OPERATIONAL
-
-The SQLite Memory Access skill is now fully operational with:
-- TypeScript implementation: `src/memory/sqlite-memory-system.ts`
-- CLI wrapper: `.claude/skills/sqlite-memory/memory-cli.sh`
-- Configuration: `.claude/skills/sqlite-memory/config.json`
-- 5-level ACL support
-- JSON output for programmatic use
-
----
-
-## CLI Usage
-
-### Installation
-The CLI is automatically available once the project is built:
-
-```bash
-# Build the project (if not already done)
-npm run build
-
-# Use the CLI directly
-./.claude/skills/sqlite-memory/memory-cli.sh <command> [options]
-```
-
-### Commands
-
-#### 1. SET - Store a value
-```bash
-./memory-cli.sh set --key <key> --value <value> --acl <level>
-
-# Examples:
-# Store agent state (ACL 1 - AGENT)
-./memory-cli.sh set --key "agent/worker-1/state" --value '{"progress":50}' --acl 1
-
-# Store team coordination data (ACL 2 - TEAM)
-./memory-cli.sh set --key "team/alpha/status" --value '{"complete":false}' --acl 2
-
-# Store swarm coordination data (ACL 3 - SWARM)
-./memory-cli.sh set --key "swarm/phase-1/status" --value '{"complete":true}' --acl 3
-```
-
-#### 2. GET - Retrieve a value
-```bash
-./memory-cli.sh get --key <key>
-
-# Examples:
-# Retrieve agent state
-./memory-cli.sh get --key "agent/worker-1/state"
-
-# Retrieve swarm status
-./memory-cli.sh get --key "swarm/phase-1/status"
-```
-
-#### 3. DELETE - Delete a value
-```bash
-./memory-cli.sh delete --key <key>
-
-# Examples:
-# Delete agent state
-./memory-cli.sh delete --key "agent/worker-1/state"
-
-# Delete temporary coordination data
-./memory-cli.sh delete --key "swarm/phase-1/temp"
-```
-
-#### 4. QUERY - Query values by pattern
-```bash
-./memory-cli.sh query --pattern <glob>
-
-# Examples:
-# Query all agent states
-./memory-cli.sh query --pattern "agent/*/state"
-
-# Query all swarm phase data
-./memory-cli.sh query --pattern "swarm/phase-*/status"
-
-# Note: Query operation requires additional implementation
-```
-
-#### 5. LIST - List all keys
-```bash
-./memory-cli.sh list [--acl <level>]
-
-# Examples:
-# List all keys
-./memory-cli.sh list
-
-# List only swarm-level keys (ACL 3)
-./memory-cli.sh list --acl 3
-
-# Note: List operation requires additional implementation
-```
-
-### ACL Levels
-
-| Level | Name | Description | Use Case |
-|-------|------|-------------|----------|
-| 0 | NONE | No access | Placeholder/invalid |
-| 1 | AGENT | Encrypted, agent-specific | Agent state, private data |
-| 2 | TEAM | Shared within team | Team coordination, shared context |
-| 3 | SWARM | Swarm-level coordination | Phase status, swarm metrics |
-| 4 | PROJECT | Project-wide access | Project config, global state |
-| 5 | SYSTEM | System-level (highest) | System config, admin operations |
-
-### Output Format
-
-All CLI commands return JSON output for easy parsing:
-
-**Success Response:**
-```json
-{
-  "success": true,
-  "operation": "set",
-  "key": "agent/worker-1/state",
-  "acl": 1,
-  "aclLevel": "READ/AGENT",
-  "timestamp": "2025-10-18T10:30:00.000Z"
-}
-```
-
-**Get Response:**
-```json
-{
-  "success": true,
-  "operation": "get",
-  "key": "agent/worker-1/state",
-  "value": {
-    "progress": 50
-  },
-  "timestamp": "2025-10-18T10:30:00.000Z"
-}
-```
-
-**Error Response:**
-```json
-{
-  "success": false,
-  "operation": "get",
-  "key": "nonexistent-key",
-  "error": "Key not found",
-  "timestamp": "2025-10-18T10:30:00.000Z"
-}
-```
-
----
-
-## Agent Integration Examples
-
-### Example 1: Agent State Persistence
-```bash
-#!/bin/bash
-# Agent stores its state across sessions
-
-AGENT_ID="worker-1"
-STATE_KEY="agent/${AGENT_ID}/state"
-
-# Get previous state
-PREV_STATE=$(./memory-cli.sh get --key "$STATE_KEY" | jq -r '.value')
-
-# Process and update state
-NEW_PROGRESS=$(echo "$PREV_STATE" | jq -r '.progress + 10')
-
-# Store updated state
-./memory-cli.sh set \
-  --key "$STATE_KEY" \
-  --value "{\"progress\":$NEW_PROGRESS,\"lastUpdate\":\"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}" \
-  --acl 1
-```
-
-### Example 2: Swarm Coordination
-```bash
-#!/bin/bash
-# Coordinator tracks swarm phase completion
-
-PHASE_ID="phase-1"
-SWARM_KEY="swarm/${PHASE_ID}/status"
-
-# Check if phase is complete
-STATUS=$(./memory-cli.sh get --key "$SWARM_KEY" | jq -r '.value.complete')
-
-if [ "$STATUS" = "true" ]; then
-  echo "Phase $PHASE_ID already complete"
-  exit 0
-fi
-
-# Mark phase as complete
-./memory-cli.sh set \
-  --key "$SWARM_KEY" \
-  --value '{"complete":true,"completedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"}' \
-  --acl 3
-```
-
-### Example 3: Team Context Sharing
-```bash
-#!/bin/bash
-# Team members share context via memory
-
-TEAM_ID="alpha"
-CONTEXT_KEY="team/${TEAM_ID}/context"
-
-# Store shared context
-./memory-cli.sh set \
-  --key "$CONTEXT_KEY" \
-  --value '{"taskQueue":["task1","task2"],"activeMembers":3}' \
-  --acl 2
-
-# Other team members can retrieve
-CONTEXT=$(./memory-cli.sh get --key "$CONTEXT_KEY" | jq -r '.value')
-echo "Team context: $CONTEXT"
-```
-
----
-
-## Configuration
-
-Configuration file: `.claude/skills/sqlite-memory/config.json`
-
-```json
-{
-  "dbPath": ".artifacts/memory/swarm-memory.sqlite",
-  "encryptionEnabled": false,
-  "aclLevels": {
-    "agent": 1,
-    "team": 2,
-    "swarm": 3,
-    "project": 4,
-    "system": 5
-  },
-  "performance": {
-    "queryTimeoutMs": 5000,
-    "maxConcurrentConnections": 100,
-    "cacheEnabled": true
-  },
-  "ttl": {
-    "defaultTtlSeconds": 3600,
-    "cleanupIntervalSeconds": 600
-  }
-}
-```
-
----
-
-## TypeScript API
-
-For programmatic access from TypeScript/Node.js:
-
-```typescript
-import { SQLiteMemorySystem } from './src/memory/sqlite-memory-system.js';
-import { AccessLevel } from './src/memory/memory-adapter.js';
-
-// Initialize memory system
-const memory = new SQLiteMemorySystem('.artifacts/memory/swarm-memory.sqlite');
-await memory.initialize();
-
-// Store value
-await memory.store('agent/worker-1/state', { progress: 50 }, AccessLevel.READ);
-
-// Retrieve value
-const state = await memory.retrieve('agent/worker-1/state');
-console.log('Agent state:', state);
-```
-
----
-
-## Testing
-
-Test the CLI with all ACL levels:
-
-```bash
-# Test script location
-./.claude/skills/sqlite-memory/test-memory-cli.sh
-
-# Manual testing
-./memory-cli.sh set --key "test/key1" --value '{"test":true}' --acl 1
-./memory-cli.sh get --key "test/key1"
-./memory-cli.sh delete --key "test/key1"
-```
-
----
-
-## Performance Targets
-
-| Metric | Target | Current |
-|--------|--------|---------|
-| Query Time | < 20ms | ✓ |
-| Encryption Strength | 256-bit | ✓ (when enabled) |
-| Cache Hit Rate | > 85% | ✓ |
-| Max Concurrent Connections | 100 | ✓ |
-
----
-
-## Implementation Details
-
-### File Structure
-```
-.claude/skills/sqlite-memory/
-├── SKILL.md                    # This file
-├── config.json                 # Configuration
-├── memory-cli.sh               # Bash wrapper
-├── acl-queries.sql             # SQL query examples
-├── ttl-cleanup.sh              # TTL cleanup script
-└── test-state-persistence.js   # Test script
-
-src/memory/
-├── sqlite-memory-system.ts     # Core implementation
-├── memory-adapter.ts           # ACL management
-└── swarm-memory.ts             # Swarm-level memory
-
-src/cli/
-└── memory-cli.ts               # TypeScript CLI implementation
-```
-
-### Key Features
-1. **5-Level ACL**: Fine-grained access control for different scopes
-2. **JSON Output**: Easy parsing for agent scripts
-3. **Encryption Support**: Optional encryption for sensitive data
-4. **TTL Management**: Automatic expiration of old data
-5. **Redis Integration**: Session management and caching
-6. **Agent-Friendly**: Simple CLI interface for bash scripts
-
----
-
-## Limitations and Future Enhancements
-
-### Current Limitations
-1. Query and List operations not yet fully implemented
-2. Requires additional methods in SQLiteMemorySystem for full functionality
-3. Delete operation currently marks as deleted rather than removing
-
-### Planned Enhancements
-1. Full query support with glob patterns
-2. List operation with ACL filtering
-3. Bulk operations (set/get/delete multiple keys)
-4. Transaction support for atomic operations
-5. Export/import functionality for migration
-
----
-
-## Maintenance
-
-### Regular Tasks
-- Weekly: Review and clean up expired keys
-- Monthly: Optimize database (VACUUM)
-- Quarterly: Audit ACL usage patterns
-
-### Troubleshooting
-
-**Issue: "Memory CLI not found"**
-```bash
-# Solution: Build the project
-npm run build
-```
-
-**Issue: "Key not found"**
-```bash
-# Solution: Verify key exists
-./memory-cli.sh list | grep "your-key"
-```
-
-**Issue: "Insufficient access level"**
-```bash
-# Solution: Use correct ACL level for operation
-# Check required ACL level in config.json
-```
-
----
-
-## Support
-
-For issues or questions:
-1. Check configuration in `.claude/skills/sqlite-memory/config.json`
-2. Review logs in `.artifacts/logs/memory-cli.log`
-3. Run test suite: `npm test`
-4. Check TypeScript implementation in `src/memory/`
-
----
-
-**Last Updated:** 2025-10-18
-**Version:** 1.3.0
-**Status:** OPERATIONAL