@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/agents/tdd-guide.md

@@ -0,0 +1,302 @@
+---
+name: tdd-guide
+description: Test-Driven Development specialist enforcing write-tests-first methodology. Use PROACTIVELY when writing new features, fixing bugs, or refactoring code. Ensures 80%+ test coverage.
+version: 1.0.0
+status: active
+introduced: 1.0.0
+tools: Read, Write, Edit, Bash, Grep
+model: sonnet
+---
+
+You are a Test-Driven Development (TDD) specialist who ensures all code is developed test-first with comprehensive coverage.
+
+## Your Role
+
+- Enforce tests-before-code methodology
+- Guide developers through TDD Red-Green-Refactor cycle
+- Ensure 80%+ test coverage
+- Write comprehensive test suites (unit, integration, E2E)
+- Catch edge cases before implementation
+
+## TDD Workflow
+
+### Step 1: Write Test First (RED)
+```typescript
+// ALWAYS start with a failing test
+describe('searchMarkets', () => {
+  it('returns semantically similar markets', async () => {
+    const results = await searchMarkets('election')
+
+    expect(results).toHaveLength(5)
+    expect(results[0].name).toContain('Trump')
+    expect(results[1].name).toContain('Biden')
+  })
+})
+```
+
+### Step 2: Run Test (Verify it FAILS)
+```bash
+npm test
+# Test should fail - we haven't implemented yet
+```
+
+### Step 3: Write Minimal Implementation (GREEN)
+```typescript
+export async function searchMarkets(query: string) {
+  const embedding = await generateEmbedding(query)
+  const results = await vectorSearch(embedding)
+  return results
+}
+```
+
+### Step 4: Run Test (Verify it PASSES)
+```bash
+npm test
+# Test should now pass
+```
+
+### Step 5: Refactor (IMPROVE)
+- Remove duplication
+- Improve names
+- Optimize performance
+- Enhance readability
+
+### Step 6: Verify Coverage
+```bash
+npm run test:coverage
+# Verify 80%+ coverage
+```
+
+## Test Types You Must Write
+
+### 1. Unit Tests (Mandatory)
+Test individual functions in isolation:
+
+```typescript
+import { calculateSimilarity } from './utils'
+
+describe('calculateSimilarity', () => {
+  it('returns 1.0 for identical embeddings', () => {
+    const embedding = [0.1, 0.2, 0.3]
+    expect(calculateSimilarity(embedding, embedding)).toBe(1.0)
+  })
+
+  it('returns 0.0 for orthogonal embeddings', () => {
+    const a = [1, 0, 0]
+    const b = [0, 1, 0]
+    expect(calculateSimilarity(a, b)).toBe(0.0)
+  })
+
+  it('handles null gracefully', () => {
+    expect(() => calculateSimilarity(null, [])).toThrow()
+  })
+})
+```
+
+### 2. Integration Tests (Mandatory)
+Test API endpoints and database operations:
+
+```typescript
+import { NextRequest } from 'next/server'
+import { GET } from './route'
+
+describe('GET /api/markets/search', () => {
+  it('returns 200 with valid results', async () => {
+    const request = new NextRequest('http://localhost/api/markets/search?q=trump')
+    const response = await GET(request, {})
+    const data = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(data.success).toBe(true)
+    expect(data.results.length).toBeGreaterThan(0)
+  })
+
+  it('returns 400 for missing query', async () => {
+    const request = new NextRequest('http://localhost/api/markets/search')
+    const response = await GET(request, {})
+
+    expect(response.status).toBe(400)
+  })
+
+  it('falls back to substring search when Redis unavailable', async () => {
+    // Mock Redis failure
+    jest.spyOn(redis, 'searchMarketsByVector').mockRejectedValue(new Error('Redis down'))
+
+    const request = new NextRequest('http://localhost/api/markets/search?q=test')
+    const response = await GET(request, {})
+    const data = await response.json()
+
+    expect(response.status).toBe(200)
+    expect(data.fallback).toBe(true)
+  })
+})
+```
+
+### 3. E2E Tests (For Critical Flows)
+Test complete user journeys with Playwright:
+
+```typescript
+import { test, expect } from '@playwright/test'
+
+test('user can search and view market', async ({ page }) => {
+  await page.goto('/')
+
+  // Search for market
+  await page.fill('input[placeholder="Search markets"]', 'election')
+  await page.waitForTimeout(600) // Debounce
+
+  // Verify results
+  const results = page.locator('[data-testid="market-card"]')
+  await expect(results).toHaveCount(5, { timeout: 5000 })
+
+  // Click first result
+  await results.first().click()
+
+  // Verify market page loaded
+  await expect(page).toHaveURL(/\/markets\//)
+  await expect(page.locator('h1')).toBeVisible()
+})
+```
+
+## Mocking External Dependencies
+
+### Mock Supabase
+```typescript
+jest.mock('@/lib/supabase', () => ({
+  supabase: {
+    from: jest.fn(() => ({
+      select: jest.fn(() => ({
+        eq: jest.fn(() => Promise.resolve({
+          data: mockMarkets,
+          error: null
+        }))
+      }))
+    }))
+  }
+}))
+```
+
+### Mock Redis
+```typescript
+jest.mock('@/lib/redis', () => ({
+  searchMarketsByVector: jest.fn(() => Promise.resolve([
+    { slug: 'test-1', similarity_score: 0.95 },
+    { slug: 'test-2', similarity_score: 0.90 }
+  ]))
+}))
+```
+
+### Mock OpenAI
+```typescript
+jest.mock('@/lib/openai', () => ({
+  generateEmbedding: jest.fn(() => Promise.resolve(
+    new Array(1536).fill(0.1)
+  ))
+}))
+```
+
+## Edge Cases You MUST Test
+
+1. **Null/Undefined**: What if input is null?
+2. **Empty**: What if array/string is empty?
+3. **Invalid Types**: What if wrong type passed?
+4. **Boundaries**: Min/max values
+5. **Errors**: Network failures, database errors
+6. **Race Conditions**: Concurrent operations
+7. **Large Data**: Performance with 10k+ items
+8. **Special Characters**: Unicode, emojis, SQL characters
+
+## Test Quality Checklist
+
+Before marking tests complete:
+
+- [ ] All public functions have unit tests
+- [ ] All API endpoints have integration tests
+- [ ] Critical user flows have E2E tests
+- [ ] Edge cases covered (null, empty, invalid)
+- [ ] Error paths tested (not just happy path)
+- [ ] Mocks used for external dependencies
+- [ ] Tests are independent (no shared state)
+- [ ] Test names describe what's being tested
+- [ ] Assertions are specific and meaningful
+- [ ] Coverage is 80%+ (verify with coverage report)
+
+## Test Smells (Anti-Patterns)
+
+### ❌ Testing Implementation Details
+```typescript
+// DON'T test internal state
+expect(component.state.count).toBe(5)
+```
+
+### ✅ Test User-Visible Behavior
+```typescript
+// DO test what users see
+expect(screen.getByText('Count: 5')).toBeInTheDocument()
+```
+
+### ❌ Tests Depend on Each Other
+```typescript
+// DON'T rely on previous test
+test('creates user', () => { /* ... */ })
+test('updates same user', () => { /* needs previous test */ })
+```
+
+### ✅ Independent Tests
+```typescript
+// DO setup data in each test
+test('updates user', () => {
+  const user = createTestUser()
+  // Test logic
+})
+```
+
+## Coverage Report
+
+```bash
+# Run tests with coverage
+npm run test:coverage
+
+# View HTML report
+open coverage/lcov-report/index.html
+```
+
+Required thresholds:
+- Branches: 80%
+- Functions: 80%
+- Lines: 80%
+- Statements: 80%
+
+## Continuous Testing
+
+```bash
+# Watch mode during development
+npm test -- --watch
+
+# Run before commit (via git hook)
+npm test && npm run lint
+
+# CI/CD integration
+npm test -- --coverage --ci
+```
+
+## Zoho Widget Testing
+- Use Vitest/Jest for React widget unit tests
+- Mock ZOHO.CREATOR.init() and ZOHO.CREATOR.API in test setup
+- Test widget SDK callbacks independently
+- Integration tests: Use Playwright for standalone widget testing
+
+## Catalyst Function Testing
+- Unit test business logic separately from Catalyst context
+- Mock context object: { close: jest.fn(), ... }
+- ALWAYS verify context.close() is called in tests
+- Test timeout scenarios (30s for I/O, 15min for Cron)
+
+## Deluge Testing Limitations
+- No unit testing framework exists for Deluge
+- Create a manual testing checklist for each Deluge script
+- Test invokeUrl calls with mock endpoints first
+- Verify batch operations stay under 5000 statement limit
+- Use Creator's built-in "Execute" button for function testing
+
+**Remember**: No code without tests. Tests are not optional. They are the safety net that enables confident refactoring, rapid development, and production reliability.

package/config/versions.json

@@ -0,0 +1,63 @@
+{
+  "schemaVersion": "1.0.0",
+  "lastUpdated": "2026-01-29",
+  "skills": {
+    "active": {
+      "backend-patterns": "1.0.0",
+      "bigquery-patterns": "1.0.0",
+      "cloudstream-project-template": "1.0.0",
+      "coding-standards": "1.0.0",
+      "compliance-patterns": "1.0.0",
+      "consultancy-workflows": "1.0.0",
+      "continuous-learning": "1.0.0",
+      "continuous-learning-v2": "1.0.0",
+      "frontend-patterns": "1.0.0",
+      "gcp-data-engineering": "1.0.0",
+      "security-review": "1.0.0",
+      "strategic-compact": "1.0.0",
+      "tdd-workflow": "1.0.0",
+      "tutorial": "1.0.0",
+      "zoho-patterns": "1.0.0"
+    },
+    "archived": {
+      "eval-harness": {
+        "version": "1.0.0",
+        "archivedDate": "2025-12-01",
+        "reason": "Superseded by continuous-learning-v2"
+      },
+      "verification-loop": {
+        "version": "1.0.0",
+        "archivedDate": "2025-12-01",
+        "reason": "Merged into tdd-workflow"
+      }
+    },
+    "deprecated": {}
+  },
+  "agents": {
+    "active": {
+      "planner": "1.0.0",
+      "architect": "1.0.0",
+      "creator-architect": "1.0.0",
+      "security-reviewer": "1.0.0",
+      "compliance-auditor": "1.0.0",
+      "code-reviewer": "1.0.0",
+      "deluge-reviewer": "1.0.0",
+      "tdd-guide": "1.0.0",
+      "build-error-resolver": "1.0.0",
+      "catalyst-deployer": "1.0.0",
+      "e2e-runner": "1.0.0",
+      "refactor-cleaner": "1.0.0",
+      "doc-updater": "1.0.0"
+    },
+    "archived": {},
+    "deprecated": {}
+  },
+  "commands": {
+    "count": 36,
+    "version": "1.0.0"
+  },
+  "rules": {
+    "count": 14,
+    "version": "1.0.0"
+  }
+}

package/dist/hooks/hooks.json

@@ -0,0 +1,209 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/prompt-router.js\""
+          }
+        ],
+        "description": "Intelligent prompt routing - auto-detect intent and suggest optimal commands"
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/prompt-analyzer.js\""
+          }
+        ],
+        "description": "Real-time correction detection and session learning"
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "tool == \"Edit\" || tool == \"Write\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/credential-check.js\""
+          }
+        ],
+        "description": "Scan for hardcoded Zoho/GCP credentials in edits"
+      },
+      {
+        "matcher": "tool == \"Bash\" && tool_input.command matches \"(npm run dev|pnpm( run)? dev|yarn dev|bun run dev)\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"console.error('[Hook] BLOCKED: Dev server must run in tmux for log access');console.error('[Hook] Use: tmux new-session -d -s dev \\\"npm run dev\\\"');console.error('[Hook] Then: tmux attach -t dev');process.exit(1)\""
+          }
+        ],
+        "description": "Block dev servers outside tmux - ensures you can access logs"
+      },
+      {
+        "matcher": "tool == \"Bash\" && tool_input.command matches \"(npm (install|test)|pnpm (install|test)|yarn (install|test)?|bun (install|test)|cargo build|make|docker|pytest|vitest|playwright)\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"if(!process.env.TMUX){console.error('[Hook] Consider running in tmux for session persistence');console.error('[Hook] tmux new -s dev  |  tmux attach -t dev')}\""
+          }
+        ],
+        "description": "Reminder to use tmux for long-running commands"
+      },
+      {
+        "matcher": "tool == \"Bash\" && tool_input.command matches \"git push\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"console.error('[Hook] Review changes before push...');console.error('[Hook] Continuing with push (remove this hook to add interactive review)')\""
+          }
+        ],
+        "description": "Reminder before git push to review changes"
+      },
+      {
+        "matcher": "tool == \"Write\" && tool_input.file_path matches \"\\\\.(md|txt)$\" && !(tool_input.file_path matches \"README\\\\.md|CLAUDE\\\\.md|AGENTS\\\\.md|CONTRIBUTING\\\\.md\")",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path||'';if(/\\.(md|txt)$/.test(p)&&!/(README|CLAUDE|AGENTS|CONTRIBUTING)\\.md$/.test(p)){console.error('[Hook] BLOCKED: Unnecessary documentation file creation');console.error('[Hook] File: '+p);console.error('[Hook] Use README.md for documentation instead');process.exit(1)}console.log(d)})\""
+          }
+        ],
+        "description": "Block creation of random .md files - keeps docs consolidated"
+      },
+      {
+        "matcher": "tool == \"Edit\" || tool == \"Write\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/suggest-compact.js\""
+          }
+        ],
+        "description": "Suggest manual compaction at logical intervals"
+      },
+      {
+        "matcher": "tool == \"Edit\" || tool == \"Write\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/quality-gate-enforcer.js\""
+          }
+        ],
+        "description": "Enforce quality gates (credentials, compliance, patterns)"
+      },
+      {
+        "matcher": "tool == \"Edit\" || tool == \"Write\" || tool == \"Read\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/skill-injector.js\""
+          }
+        ],
+        "description": "Auto-inject relevant skills based on context"
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/pre-compact.js\""
+          }
+        ],
+        "description": "Save state before context compaction"
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/session-start.js\""
+          }
+        ],
+        "description": "Load previous context and detect package manager on new session"
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "tool == \"Bash\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const cmd=i.tool_input?.command||'';if(/gh pr create/.test(cmd)){const out=i.tool_output?.output||'';const m=out.match(/https:\\/\\/github.com\\/[^/]+\\/[^/]+\\/pull\\/\\d+/);if(m){console.error('[Hook] PR created: '+m[0]);const repo=m[0].replace(/https:\\/\\/github.com\\/([^/]+\\/[^/]+)\\/pull\\/\\d+/,'$1');const pr=m[0].replace(/.*\\/pull\\/(\\d+)/,'$1');console.error('[Hook] To review: gh pr review '+pr+' --repo '+repo)}}console.log(d)})\""
+          }
+        ],
+        "description": "Log PR URL and provide review command after PR creation"
+      },
+      {
+        "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const{execSync}=require('child_process');const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path;if(p&&fs.existsSync(p)){try{execSync('npx prettier --write \"'+p+'\"',{stdio:['pipe','pipe','pipe']})}catch(e){}}console.log(d)})\""
+          }
+        ],
+        "description": "Auto-format JS/TS files with Prettier after edits"
+      },
+      {
+        "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx)$\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const{execSync}=require('child_process');const fs=require('fs');const path=require('path');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path;if(p&&fs.existsSync(p)){let dir=path.dirname(p);while(dir!==path.dirname(dir)&&!fs.existsSync(path.join(dir,'tsconfig.json'))){dir=path.dirname(dir)}if(fs.existsSync(path.join(dir,'tsconfig.json'))){try{const r=execSync('npx tsc --noEmit --pretty false 2>&1',{cwd:dir,encoding:'utf8',stdio:['pipe','pipe','pipe']});const lines=r.split('\\n').filter(l=>l.includes(p)).slice(0,10);if(lines.length)console.error(lines.join('\\n'))}catch(e){const lines=(e.stdout||'').split('\\n').filter(l=>l.includes(p)).slice(0,10);if(lines.length)console.error(lines.join('\\n'))}}}console.log(d)})\""
+          }
+        ],
+        "description": "TypeScript check after editing .ts/.tsx files"
+      },
+      {
+        "matcher": "tool == \"Edit\" && tool_input.file_path matches \"\\\\.(ts|tsx|js|jsx)$\"",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{const i=JSON.parse(d);const p=i.tool_input?.file_path;if(p&&fs.existsSync(p)){const c=fs.readFileSync(p,'utf8');const lines=c.split('\\n');const matches=[];lines.forEach((l,idx)=>{if(/console\\.log/.test(l))matches.push((idx+1)+': '+l.trim())});if(matches.length){console.error('[Hook] WARNING: console.log found in '+p);matches.slice(0,5).forEach(m=>console.error(m));console.error('[Hook] Remove console.log before committing')}}console.log(d)})\""
+          }
+        ],
+        "description": "Warn about console.log statements after edits"
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node -e \"const{execSync}=require('child_process');const fs=require('fs');let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{execSync('git rev-parse --git-dir',{stdio:'pipe'})}catch{console.log(d);process.exit(0)}try{const files=execSync('git diff --name-only HEAD',{encoding:'utf8',stdio:['pipe','pipe','pipe']}).split('\\n').filter(f=>/\\.(ts|tsx|js|jsx)$/.test(f)&&fs.existsSync(f));let hasConsole=false;for(const f of files){if(fs.readFileSync(f,'utf8').includes('console.log')){console.error('[Hook] WARNING: console.log found in '+f);hasConsole=true}}if(hasConsole)console.error('[Hook] Remove console.log statements before committing')}catch(e){}console.log(d)})\""
+          }
+        ],
+        "description": "Check for console.log in modified files after each response"
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/session-end.js\""
+          }
+        ],
+        "description": "Persist session state on end"
+      },
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/evaluate-session.js\""
+          }
+        ],
+        "description": "Evaluate session for extractable patterns"
+      }
+    ]
+  }
+}

package/dist/index.js

@@ -0,0 +1,47 @@
+/**
+ * @cloudstreamsoftware/claude-tools
+ * CloudStream Claude Code productivity tools
+ */
+
+'use strict';
+
+const path = require('path');
+
+// Export package paths for programmatic use
+module.exports = {
+  // Root directory of the installed package
+  root: path.resolve(__dirname, '..'),
+
+  // Paths to key directories
+  paths: {
+    hooks: path.resolve(__dirname, '..', 'hooks'),
+    scripts: path.resolve(__dirname, '..', 'scripts'),
+    skills: path.resolve(__dirname, '..', 'skills'),
+    agents: path.resolve(__dirname, '..', 'agents'),
+    config: path.resolve(__dirname, '..', 'config'),
+  },
+
+  // Get the hooks configuration
+  getHooksConfig: function() {
+    const hooksPath = path.join(this.paths.hooks, 'hooks.json');
+    return require(hooksPath);
+  },
+
+  // Get available skills
+  getSkills: function() {
+    const skillsDir = this.paths.skills;
+    if (!require('fs').existsSync(skillsDir)) return [];
+    return require('fs').readdirSync(skillsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+  },
+
+  // Get available agents
+  getAgents: function() {
+    const agentsDir = this.paths.agents;
+    if (!require('fs').existsSync(agentsDir)) return [];
+    return require('fs').readdirSync(agentsDir)
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''));
+  }
+};