cmp-standards 2.0.1 → 2.4.0

package/README.md

@@ -1,45 +1,101 @@
-# cmp-memory-system
+# cmp-standards
 
-> Unified memory & workflow system for Claude Code projects
+> Unified standards, memory, ESLint rules & workflow system for Claude Code projects
 
 ## Features
 
+### Core
+- **ESLint Plugin** - 11+ custom rules for code quality
 - **Task Tracking** - Automatic task registration in database
 - **Idea Capture** - Collect ideas and improvements during work
 - **Work Plans** - Persistent work plans across sessions
 - **Memory System** - Session context and memory management
-- **Auto-Improvement** - Pattern detection → ESLint rule generation
+- **Auto-Improvement** - Pattern detection and ESLint rule generation
 - **Dashboard** - Web UI for visualization
 - **MCP Server** - Model Context Protocol integration
 - **Analytics** - Usage tracking and insights
 
+### Cloud Infrastructure (v2.2.0+)
+- **Turso** (SQLite Edge) - Tasks, improvements, memories
+- **Upstash Redis** - Session cache, rate limiting
+- **Upstash Vector** - Semantic search with embeddings
+- **Cloud Hooks** - Session tracking across IDE restarts
+
+## Cloud Quick Start
+
+```typescript
+import { cloud } from 'cmp-standards'
+
+// Initialize cloud services
+await cloud.init()
+
+// Start work session
+const session = await cloud.startWorkSession('MYPROJECT')
+console.log(`Active tasks: ${session.activeTasks.length}`)
+
+// Start task
+const taskId = await cloud.startTask('MYPROJECT', session.sessionId, {
+  title: 'Implement feature X',
+  plan: ['Step 1', 'Step 2'],
+  domain: 'features'
+})
+
+// Complete task (requires at least 1 improvement)
+await cloud.completeTask(taskId, {
+  result: 'success',
+  improvements: [{
+    area: 'features',
+    title: 'Add caching',
+    description: 'Could cache API responses',
+    priority: 'medium'
+  }],
+  lessons: ['Pattern X works better']
+})
+```
+
+## Environment Variables
+
+```env
+# Turso (SQLite Edge)
+TURSO_DATABASE_URL=libsql://your-db.turso.io
+TURSO_AUTH_TOKEN=your-token
+
+# Upstash Redis
+UPSTASH_REDIS_REST_URL=https://your-redis.upstash.io
+UPSTASH_REDIS_REST_TOKEN=your-token
+
+# Upstash Vector
+UPSTASH_VECTOR_REST_URL=https://your-vector.upstash.io
+UPSTASH_VECTOR_REST_TOKEN=your-token
+```
+
 ## Installation
 
 ```bash
-npm install cmp-memory-system
+npm install cmp-standards
 ```
 
 ## Quick Start
 
 ```bash
 # Initialize in project
-cmp-memory init --system MYPROJECT --name "My Project"
+cmp-standards init --system MYPROJECT --name "My Project"
 
 # Check status
-cmp-memory status
+cmp-standards status
 
-# Check status
-claude-memory status
+# Start dashboard
+cmp-standards dashboard
 ```
 
 ## CLI Commands
 
-### `claude-memory init`
+### `cmp-standards init`
 
-Initialize memory system in current project.
+Initialize the system in current project.
 
 ```bash
-claude-memory init [options]
+cmp-standards init [options]
 
 Options:
   -s, --system <system>  System identifier (SWARMSCALE, PANEL)
@@ -47,100 +103,100 @@ Options:
   -f, --force            Overwrite existing configuration
 ```
 
-### `claude-memory generate`
+### `cmp-standards generate`
 
 Generate embedding registry from documentation.
 
 ```bash
-claude-memory generate [options]
+cmp-standards generate [options]
 
 Options:
   -i, --incremental     Only update changed files
   --files <files>       Specific files (comma-separated)
 ```
 
-### `claude-memory scan`
+### `cmp-standards scan`
 
 Scan codebase for patterns.
 
 ```bash
-claude-memory scan [options]
+cmp-standards scan [options]
 
 Options:
   -d, --dir <directory>   Directory to scan (default: src)
   -t, --threshold <n>     Pattern threshold (default: 3)
 ```
 
-### `claude-memory improve`
+### `cmp-standards improve`
 
 Run auto-improvement for triggered patterns.
 
 ```bash
-claude-memory improve [options]
+cmp-standards improve [options]
 
 Options:
   --dry-run              Show without making changes
   -p, --pattern <id>     Specific pattern to improve
 ```
 
-### `claude-memory status`
+### `cmp-standards status`
 
 Show memory system status.
 
-### `claude-memory dashboard`
+### `cmp-standards dashboard`
 
 Start the memory dashboard web UI.
 
 ```bash
-claude-memory dashboard [options]
+cmp-standards dashboard [options]
 
 Options:
   -p, --port <port>  Port to run on (default: 3847)
   --no-open          Don't open browser automatically
 ```
 
-### `claude-memory analytics`
+### `cmp-standards analytics`
 
 Show analytics and system health.
 
 ```bash
-claude-memory analytics [options]
+cmp-standards analytics [options]
 
 Options:
   -p, --period <period>  Time period (day, week, month)
   --json                 Output as JSON
 ```
 
-### `claude-memory feedback`
+### `cmp-standards feedback`
 
 View feedback statistics.
 
-### `claude-memory mcp`
+### `cmp-standards mcp`
 
 Start the MCP server for Claude integration.
 
 ---
 
-## Workflow Commands (NEW)
+## Workflow Commands
 
-### `claude-memory tasks`
+### `cmp-standards tasks`
 
 View and manage tasks.
 
 ```bash
-claude-memory tasks [options]
+cmp-standards tasks [options]
 
 Options:
   -a, --all              Show all tasks including completed
   -l, --limit <number>   Limit number of tasks (default: 10)
 ```
 
-### `claude-memory ideas`
+### `cmp-standards ideas`
 
 View captured ideas.
 
 ```bash
-claude-memory ideas [options]
+cmp-standards ideas [options]
 
 Options:
   -c, --category <cat>   Filter by category (feature, refactor, bug, optimization, documentation)
@@ -148,12 +204,12 @@ Options:
   -l, --limit <number>   Limit number of ideas (default: 20)
 ```
 
-### `claude-memory improvements`
+### `cmp-standards improvements`
 
 View suggested improvements.
 
 ```bash
-claude-memory improvements [options]
+cmp-standards improvements [options]
 
 Options:
   -t, --type <type>      Filter by type (code_quality, performance, security, ux, architecture)
@@ -161,12 +217,12 @@ Options:
   -l, --limit <number>   Limit number (default: 20)
 ```
 
-### `claude-memory plan`
+### `cmp-standards plan`
 
 Manage work plans.
 
 ```bash
-claude-memory plan [options]
+cmp-standards plan [options]
 
 Options:
   -s, --status           Show current plan status
@@ -175,20 +231,20 @@ Options:
   -h, --history          Show plan history
 ```
 
-### `claude-memory capture <text>`
+### `cmp-standards capture <text>`
 
 Quick capture an idea or improvement. Auto-categorizes based on content.
 
 ```bash
-claude-memory capture "Consider adding caching to API calls"
+cmp-standards capture "Consider adding caching to API calls"
 ```
 
-### `claude-memory export`
+### `cmp-standards export`
 
 Export ideas and improvements as markdown.
 
 ```bash
-claude-memory export [options]
+cmp-standards export [options]
 
 Options:
   -o, --output <file>    Output file (default: IDEAS_AND_IMPROVEMENTS.md)
@@ -199,13 +255,22 @@ Options:
 ## Architecture
 
 ```
-@metanautical/claude-memory
+cmp-standards
 ├── src/
 │   ├── hooks/
 │   │   ├── session-start.ts      # Context loader on session start
 │   │   ├── pre-tool-use.ts       # Guards + embedding injection
 │   │   ├── post-tool-use.ts      # Record changes after Edit/Write
 │   │   └── memory-checkpoint.ts  # Record learnings after changes
+│   ├── eslint/
+│   │   ├── index.ts              # ESLint plugin entry
+│   │   ├── rules/                # Custom ESLint rules
+│   │   └── config-builder.ts     # Dynamic config generation
+│   ├── services/
+│   │   ├── TaskTracker.ts        # Task tracking
+│   │   ├── IdeaCollector.ts      # Idea/improvement capture
+│   │   ├── WorkPlanManager.ts    # Work plan management
+│   │   └── ...                   # Other services
 │   ├── registry/
 │   │   ├── generator.ts          # Parse docs → embeddings
 │   │   └── embeddings.ts         # OpenAI/Gemini embedding service
@@ -220,13 +285,10 @@ Options:
 │   ├── dashboard/
 │   │   ├── server.ts             # Express dashboard server
 │   │   └── ui.ts                 # React UI generator
-│   ├── feedback/
-│   │   └── collector.ts          # User feedback collection
-│   ├── analytics/
-│   │   └── tracker.ts            # Usage analytics & insights
 │   ├── utils/
 │   │   ├── config.ts             # Configuration management
-│   │   └── paths.ts              # Path utilities
+│   │   ├── paths.ts              # Path utilities with traversal protection
+│   │   └── git.ts                # Safe git operations (simple-git)
 │   ├── types/
 │   │   └── index.ts              # Type definitions
 │   ├── cli/
@@ -277,7 +339,7 @@ Options:
         "matcher": "Task",
         "hooks": [{
           "type": "command",
-          "command": "npx tsx node_modules/@metanautical/claude-memory/dist/hooks/pre-tool-use.js"
+          "command": "npx tsx node_modules/cmp-standards/dist/hooks/pre-tool-use.js"
         }]
       }
     ],
@@ -286,14 +348,14 @@ Options:
         "matcher": "",
         "hooks": [{
           "type": "command",
-          "command": "npx tsx node_modules/@metanautical/claude-memory/dist/hooks/session-start.js"
+          "command": "npx tsx node_modules/cmp-standards/dist/hooks/session-start.js"
         }]
       }
     ]
   },
   "plugins": {
-    "metanautical-memory": {
-      "version": "1.0.0",
+    "cmp-standards": {
+      "version": "2.0.0",
       "enabled": true
     }
   }
@@ -310,7 +372,7 @@ Executes on session start:
 3. Returns formatted context
 
 ```typescript
-import { SessionStartHook } from '@metanautical/claude-memory/hooks'
+import { SessionStartHook } from 'cmp-standards/hooks'
 
 const hook = new SessionStartHook()
 const result = await hook.execute()
@@ -324,7 +386,7 @@ Executes before Edit/Write/Task tools:
 2. **Task**: Injects relevant knowledge via embeddings
 
 ```typescript
-import { PreToolUseHook } from '@metanautical/claude-memory/hooks'
+import { PreToolUseHook } from 'cmp-standards/hooks'
 
 const hook = new PreToolUseHook()
 const result = await hook.execute({
@@ -337,6 +399,30 @@ if (result.mode === 'block') {
 }
 ```
 
+## ESLint Plugin
+
+The package includes a custom ESLint plugin with 11+ rules.
+
+### Using the ESLint Plugin
+
+```javascript
+// eslint.config.mjs
+import cmpStandards from 'cmp-standards/eslint'
+
+export default [
+  ...cmpStandards.configs.recommended,
+]
+```
+
+### Dynamic Configuration
+
+```typescript
+import { generateConfig } from 'cmp-standards/eslint'
+
+// Generate config based on project structure
+const config = await generateConfig(process.cwd())
+```
+
 ## Auto-Improvement
 
 ### Pattern Detection
@@ -355,15 +441,15 @@ When a pattern is detected 3+ times:
 
 ```bash
 # Scan for patterns
-claude-memory scan
+cmp-standards scan
 
 # Output:
-# 🔴 any-type [high]
+# any-type [high]
 #    Count: 5, Files: 3
-# ⚠️ Patterns ready for auto-improvement
+# Patterns ready for auto-improvement
 
 # Generate ESLint rule
-claude-memory improve
+cmp-standards improve
 
 # Creates: eslint-plugin-charter/rules/no-any-type.js
 ```
@@ -376,7 +462,7 @@ import {
   PatternDetector,
   ESLintGenerator,
   RegistryGenerator
-} from '@metanautical/claude-memory'
+} from 'cmp-standards'
 
 // Load config
 const config = await loadConfig(process.cwd())
@@ -415,6 +501,34 @@ db.select().from(devItems).where(eq(devItems.system, 'SWARMSCALE'))
 db.select().from(devItems)
 ```
 
+## Security Features
+
+### Path Traversal Protection
+
+All path operations are validated to prevent directory traversal attacks:
+
+```typescript
+import { validateSafePath, safeJoin } from 'cmp-standards'
+
+// Throws PathTraversalError if path escapes base
+validateSafePath(projectRoot, userPath)
+
+// Safe path joining with validation
+const safePath = safeJoin(projectRoot, 'subdir', filename)
+```
+
+### Safe Git Operations
+
+Git operations use `simple-git` instead of shell commands to prevent command injection:
+
+```typescript
+import { getCurrentBranch, getRecentChanges } from 'cmp-standards'
+
+// Safe - uses simple-git internally
+const branch = await getCurrentBranch(projectRoot)
+const changes = await getRecentChanges(projectRoot, { commits: 10 })
+```
+
 ## Environment Variables
 
 ```bash
@@ -451,7 +565,7 @@ The MCP (Model Context Protocol) server exposes memory tools that Claude can use
 
 ```bash
 # Start MCP server
-claude-memory mcp
+cmp-standards mcp
 ```
 
 **Available Tools:**
@@ -468,7 +582,7 @@ claude-memory mcp
 Start the standalone web dashboard:
 
 ```bash
-claude-memory dashboard
+cmp-standards dashboard
 # Opens http://localhost:3847
 ```
 
@@ -480,50 +594,6 @@ claude-memory dashboard
 - Create new memories
 - View analytics and system health
 
-## Feedback Loop
-
-The feedback system adjusts memory relevance based on user feedback:
-
-```typescript
-import { createFeedbackCollector } from '@metanautical/claude-memory'
-
-const collector = createFeedbackCollector('SWARMSCALE')
-
-// Submit feedback
-await collector.submitFeedback(memoryId, true, 'Very helpful!')
-
-// Get feedback stats
-const stats = await collector.getStats()
-// { helpfulRate: 0.85, topHelpfulMemories: [...] }
-
-// Get suggestions for deprecation
-const deprecations = await collector.getSuggestedDeprecations()
-```
-
-## Analytics
-
-Track usage and get insights:
-
-```typescript
-import { createAnalyticsTracker } from '@metanautical/claude-memory'
-
-const tracker = createAnalyticsTracker('SWARMSCALE')
-
-// Track an event
-await tracker.track('memory_access', { memoryId: '...' })
-
-// Get usage stats
-const usage = await tracker.getUsageStats('week')
-// { sessions: 12, memoriesCreated: 5, searchesPerformed: 23, ... }
-
-// Get system health
-const health = await tracker.getSystemHealth()
-// { status: 'healthy', issues: [], recommendations: [...] }
-
-// Generate full report
-const report = await tracker.generateReport()
-```
-
 ## Database Configuration
 
 Set environment variables for database connection:
@@ -538,4 +608,4 @@ DATABASE_NAME=metanautical
 
 ## License
 
-MIT - MetaNautical Group
+MIT - Carlos Martin Pavon