anchi-toolkit 1.0.0 → 1.2.1

package/dist/.cursor/hooks/telegram_notify.sh

@@ -0,0 +1,158 @@
+#!/bin/bash
+
+# Telegram Notification Hook for Claude Code (Project-Specific)
+# This hook sends a notification to Telegram when Claude finishes a task
+
+set -euo pipefail
+
+# Load environment variables with priority: process.env > .cursor/.env > .cursor/hooks/.env
+load_env() {
+    # 1. Start with lowest priority: .cursor/hooks/.env
+    if [[ -f "$(dirname "$0")/.env" ]]; then
+        set -a
+        source "$(dirname "$0")/.env"
+        set +a
+    fi
+
+    # 2. Override with .cursor/.env
+    if [[ -f .cursor/.env ]]; then
+        set -a
+        source .cursor/.env
+        set +a
+    fi
+
+    # 3. Process env (already loaded) has highest priority - no action needed
+    # Variables already in process.env will not be overwritten by 'source'
+}
+
+load_env
+
+# Read JSON input from stdin
+INPUT=$(cat)
+
+# Extract relevant information from the hook input
+HOOK_TYPE=$(echo "$INPUT" | jq -r '.hookType // "unknown"')
+PROJECT_DIR=$(echo "$INPUT" | jq -r '.projectDir // ""')
+TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+SESSION_ID=$(echo "$INPUT" | jq -r '.sessionId // ""')
+PROJECT_NAME=$(basename "$PROJECT_DIR")
+
+# Configuration - these will be set via environment variables
+TELEGRAM_BOT_TOKEN="${TELEGRAM_BOT_TOKEN:-}"
+TELEGRAM_CHAT_ID="${TELEGRAM_CHAT_ID:-}"
+
+# Validate required environment variables
+if [[ -z "$TELEGRAM_BOT_TOKEN" ]]; then
+    echo "Error: TELEGRAM_BOT_TOKEN environment variable not set" >&2
+    exit 1
+fi
+
+if [[ -z "$TELEGRAM_CHAT_ID" ]]; then
+    echo "Error: TELEGRAM_CHAT_ID environment variable not set" >&2
+    exit 1
+fi
+
+# Function to send Telegram message
+send_telegram_message() {
+    local message="$1"
+    local url="https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage"
+    
+    # Escape special characters for JSON
+    local escaped_message=$(echo "$message" | jq -Rs .)
+    
+    local payload=$(cat <<EOF
+{
+    "chat_id": "${TELEGRAM_CHAT_ID}",
+    "text": ${escaped_message},
+    "parse_mode": "Markdown",
+    "disable_web_page_preview": true
+}
+EOF
+)
+    
+    curl -s -X POST \
+        -H "Content-Type: application/json" \
+        -d "$payload" \
+        "$url" > /dev/null
+}
+
+# Generate summary based on hook type
+case "$HOOK_TYPE" in
+    "Stop")
+        # Extract tool usage summary
+        TOOLS_USED=$(echo "$INPUT" | jq -r '.toolsUsed[]?.tool // empty' | sort | uniq -c | sort -nr)
+        FILES_MODIFIED=$(echo "$INPUT" | jq -r '.toolsUsed[]? | select(.tool == "Edit" or .tool == "Write" or .tool == "MultiEdit") | .parameters.file_path // empty' | sort | uniq)
+        
+        # Count operations
+        TOTAL_TOOLS=$(echo "$INPUT" | jq '.toolsUsed | length')
+        
+        # Build summary message
+        MESSAGE="🚀 *DevPocket Task Completed*
+        
+📅 *Time:* ${TIMESTAMP}
+📁 *Project:* ${PROJECT_NAME}
+🔧 *Total Operations:* ${TOTAL_TOOLS}
+🆔 *Session:* ${SESSION_ID:0:8}...
+
+*Tools Used:*"
+
+        if [[ -n "$TOOLS_USED" ]]; then
+            MESSAGE="${MESSAGE}
+\`\`\`
+${TOOLS_USED}
+\`\`\`"
+        else
+            MESSAGE="${MESSAGE}
+None"
+        fi
+
+        if [[ -n "$FILES_MODIFIED" ]]; then
+            MESSAGE="${MESSAGE}
+
+*Files Modified:*"
+            while IFS= read -r file; do
+                if [[ -n "$file" ]]; then
+                    # Show relative path from project root
+                    relative_file=$(echo "$file" | sed "s|^${PROJECT_DIR}/||")
+                    MESSAGE="${MESSAGE}
+• ${relative_file}"
+                fi
+            done <<< "$FILES_MODIFIED"
+        fi
+        
+        MESSAGE="${MESSAGE}
+
+📍 *Location:* \`${PROJECT_DIR}\`"
+        ;;
+        
+    "SubagentStop")
+        SUBAGENT_TYPE=$(echo "$INPUT" | jq -r '.subagentType // "unknown"')
+        MESSAGE="🤖 *DevPocket Subagent Completed*
+
+📅 *Time:* ${TIMESTAMP}
+📁 *Project:* ${PROJECT_NAME}
+🔧 *Agent Type:* ${SUBAGENT_TYPE}
+🆔 *Session:* ${SESSION_ID:0:8}...
+
+Specialized agent completed its task.
+
+📍 *Location:* \`${PROJECT_DIR}\`"
+        ;;
+        
+    *)
+        MESSAGE="📝 *DevPocket Code Event*
+
+📅 *Time:* ${TIMESTAMP}
+📁 *Project:* ${PROJECT_NAME}
+📋 *Event:* ${HOOK_TYPE}
+🆔 *Session:* ${SESSION_ID:0:8}...
+
+📍 *Location:* \`${PROJECT_DIR}\`"
+        ;;
+esac
+
+# Send the notification
+send_telegram_message "$MESSAGE"
+
+# Log the notification (optional)
+echo "Telegram notification sent for $HOOK_TYPE event in project $PROJECT_NAME" >&2

package/dist/.cursor/hooks/tests/test-ckignore.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for .ckignore functionality
+ * Tests that scout-block.sh respects .ckignore patterns
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const scriptPath = path.join(__dirname, '..', 'scout-block.sh');
+const ckignorePath = path.join(__dirname, '..', '..', '.ckignore');
+const ckignoreBackupPath = ckignorePath + '.backup';
+
+// Backup original .ckignore if exists
+let originalCkignore = null;
+if (fs.existsSync(ckignorePath)) {
+  originalCkignore = fs.readFileSync(ckignorePath, 'utf-8');
+  fs.copyFileSync(ckignorePath, ckignoreBackupPath);
+}
+
+function runTest(name, input, expected) {
+  try {
+    const inputJson = JSON.stringify(input);
+    execSync(`bash "${scriptPath}"`, {
+      input: inputJson,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const actual = 'ALLOWED';
+    const success = actual === expected;
+    return { name, expected, actual, success };
+  } catch (error) {
+    const actual = error.status === 2 ? 'BLOCKED' : 'ERROR';
+    const success = actual === expected;
+    return { name, expected, actual, success, error: error.stderr?.toString().trim() };
+  }
+}
+
+function writeCkignore(patterns) {
+  fs.writeFileSync(ckignorePath, patterns.join('\n') + '\n');
+}
+
+function restoreCkignore() {
+  if (originalCkignore !== null) {
+    fs.writeFileSync(ckignorePath, originalCkignore);
+    if (fs.existsSync(ckignoreBackupPath)) {
+      fs.unlinkSync(ckignoreBackupPath);
+    }
+  }
+}
+
+console.log('Testing .ckignore functionality...\n');
+
+let passed = 0;
+let failed = 0;
+
+// Test 1: Default patterns work (with existing .ckignore)
+console.log('--- Test 1: Default patterns from .ckignore ---');
+let result = runTest(
+  'node_modules blocked (default)',
+  { tool_name: 'Read', tool_input: { file_path: 'node_modules/pkg.json' } },
+  'BLOCKED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+// Test 2: Custom pattern - only block 'vendor' directory
+console.log('\n--- Test 2: Custom .ckignore with only "vendor" ---');
+writeCkignore(['# Custom ignore', 'vendor']);
+
+result = runTest(
+  'vendor blocked (custom)',
+  { tool_name: 'Read', tool_input: { file_path: 'vendor/lib.js' } },
+  'BLOCKED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+result = runTest(
+  'node_modules ALLOWED when not in .ckignore',
+  { tool_name: 'Read', tool_input: { file_path: 'node_modules/pkg.json' } },
+  'ALLOWED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+// Test 3: Multiple custom patterns
+console.log('\n--- Test 3: Multiple custom patterns ---');
+writeCkignore(['vendor', 'temp', '.cache']);
+
+result = runTest(
+  'vendor blocked',
+  { tool_name: 'Grep', tool_input: { pattern: 'test', path: 'vendor' } },
+  'BLOCKED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+result = runTest(
+  'temp blocked',
+  { tool_name: 'Bash', tool_input: { command: 'ls temp/' } },
+  'BLOCKED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+result = runTest(
+  '.cache blocked',
+  { tool_name: 'Glob', tool_input: { pattern: '.cache/**' } },
+  'BLOCKED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+result = runTest(
+  'src still allowed',
+  { tool_name: 'Read', tool_input: { file_path: 'src/index.js' } },
+  'ALLOWED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+// Test 4: Comments and empty lines ignored
+console.log('\n--- Test 4: Comments and empty lines handled ---');
+writeCkignore(['# This is a comment', '', 'blockeddir', '# Another comment', '']);
+
+result = runTest(
+  'blockeddir blocked',
+  { tool_name: 'Read', tool_input: { file_path: 'blockeddir/file.txt' } },
+  'BLOCKED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+result = runTest(
+  'otherdir allowed',
+  { tool_name: 'Read', tool_input: { file_path: 'otherdir/file.txt' } },
+  'ALLOWED'
+);
+if (result.success) {
+  console.log(`✓ ${result.name}: ${result.actual}`);
+  passed++;
+} else {
+  console.log(`✗ ${result.name}: expected ${result.expected}, got ${result.actual}`);
+  failed++;
+}
+
+// Restore original .ckignore
+restoreCkignore();
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/dist/.cursor/hooks/tests/test-modularization-hook.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for modularization-hook.js (PostToolUse hook)
+ * Tests if the hook correctly identifies files exceeding LOC threshold
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Create a temporary test file
+const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'modularization-test-'));
+const testFilePath = path.join(tempDir, 'test-file.js');
+
+// Create file with 250 lines (exceeds 200 LOC threshold)
+const longContent = Array(250).fill('// Test line').join('\n');
+fs.writeFileSync(testFilePath, longContent);
+
+// Create file with 50 lines (under threshold)
+const shortFilePath = path.join(tempDir, 'short-file.js');
+const shortContent = Array(50).fill('// Test line').join('\n');
+fs.writeFileSync(shortFilePath, shortContent);
+
+const testCases = [
+  {
+    name: 'Write tool with file exceeding LOC threshold',
+    input: {
+      tool_name: 'Write',
+      tool_input: {
+        file_path: testFilePath,
+        content: longContent
+      }
+    },
+    expectSuggestion: true
+  },
+  {
+    name: 'Edit tool with file exceeding LOC threshold',
+    input: {
+      tool_name: 'Edit',
+      tool_input: {
+        file_path: testFilePath,
+        old_string: '// Test line',
+        new_string: '// Modified line'
+      }
+    },
+    expectSuggestion: true
+  },
+  {
+    name: 'Write tool with short file (under threshold)',
+    input: {
+      tool_name: 'Write',
+      tool_input: {
+        file_path: shortFilePath,
+        content: shortContent
+      }
+    },
+    expectSuggestion: false
+  },
+  {
+    name: 'Write tool with non-existent file',
+    input: {
+      tool_name: 'Write',
+      tool_input: {
+        file_path: '/tmp/non-existent-file.js',
+        content: 'test'
+      }
+    },
+    expectSuggestion: false
+  }
+];
+
+console.log('Testing modularization-hook.js...\n');
+
+const scriptPath = path.join(__dirname, '..', 'modularization-hook.js');
+let passed = 0;
+let failed = 0;
+
+for (const test of testCases) {
+  try {
+    const input = JSON.stringify(test.input);
+    const result = execSync(`node "${scriptPath}"`, {
+      input,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, MODULARIZATION_HOOK_DEBUG: 'false' }
+    });
+
+    let hasSuggestion = false;
+    if (result && result.trim()) {
+      try {
+        const output = JSON.parse(result.trim());
+        hasSuggestion = output.hookSpecificOutput?.additionalContext?.includes('LOC');
+      } catch (e) {
+        // Not valid JSON or no output
+      }
+    }
+
+    const success = hasSuggestion === test.expectSuggestion;
+
+    if (success) {
+      console.log(`✓ ${test.name}: ${hasSuggestion ? 'suggestion shown' : 'no suggestion'}`);
+      passed++;
+    } else {
+      console.log(`✗ ${test.name}: expected ${test.expectSuggestion ? 'suggestion' : 'no suggestion'}, got ${hasSuggestion ? 'suggestion' : 'no suggestion'}`);
+      if (result) {
+        console.log(`  Output: ${result.trim()}`);
+      }
+      failed++;
+    }
+  } catch (error) {
+    console.log(`✗ ${test.name}: error executing hook`);
+    console.log(`  Error: ${error.message}`);
+    if (error.stderr) {
+      console.log(`  Stderr: ${error.stderr.toString()}`);
+    }
+    failed++;
+  }
+}
+
+// Cleanup
+fs.rmSync(tempDir, { recursive: true, force: true });
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/dist/.cursor/hooks/tests/test-scout-block.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for scout-block.sh hook
+ * Tests various tool inputs to verify blocking logic
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+const testCases = [
+  // Directory access - should be BLOCKED
+  {
+    name: 'Bash: ls node_modules',
+    input: { tool_name: 'Bash', tool_input: { command: 'ls node_modules' } },
+    expected: 'BLOCKED'
+  },
+  {
+    name: 'Bash: cd build',
+    input: { tool_name: 'Bash', tool_input: { command: 'cd build' } },
+    expected: 'BLOCKED'
+  },
+  {
+    name: 'Bash: cat dist/bundle.js',
+    input: { tool_name: 'Bash', tool_input: { command: 'cat dist/bundle.js' } },
+    expected: 'BLOCKED'
+  },
+  {
+    name: 'Grep with node_modules path',
+    input: { tool_name: 'Grep', tool_input: { pattern: 'test', path: 'node_modules' } },
+    expected: 'BLOCKED'
+  },
+  {
+    name: 'Glob with node_modules pattern',
+    input: { tool_name: 'Glob', tool_input: { pattern: '**/node_modules/**' } },
+    expected: 'BLOCKED'
+  },
+  {
+    name: 'Read with node_modules file_path',
+    input: { tool_name: 'Read', tool_input: { file_path: 'node_modules/package.json' } },
+    expected: 'BLOCKED'
+  },
+
+  // Build commands - should be ALLOWED
+  {
+    name: 'Bash: npm build',
+    input: { tool_name: 'Bash', tool_input: { command: 'npm build' } },
+    expected: 'ALLOWED'
+  },
+  {
+    name: 'Bash: pnpm build',
+    input: { tool_name: 'Bash', tool_input: { command: 'pnpm build' } },
+    expected: 'ALLOWED'
+  },
+  {
+    name: 'Bash: yarn build',
+    input: { tool_name: 'Bash', tool_input: { command: 'yarn build' } },
+    expected: 'ALLOWED'
+  },
+  {
+    name: 'Bash: npm run build',
+    input: { tool_name: 'Bash', tool_input: { command: 'npm run build' } },
+    expected: 'ALLOWED'
+  },
+  {
+    name: 'Bash: pnpm --filter web run build',
+    input: { tool_name: 'Bash', tool_input: { command: 'pnpm --filter web run build 2>&1 | tail -100' } },
+    expected: 'ALLOWED'
+  },
+
+  // Safe operations - should be ALLOWED
+  {
+    name: 'Grep with safe path',
+    input: { tool_name: 'Grep', tool_input: { pattern: 'test', path: 'src' } },
+    expected: 'ALLOWED'
+  },
+  {
+    name: 'Read with safe file_path',
+    input: { tool_name: 'Read', tool_input: { file_path: 'src/index.js' } },
+    expected: 'ALLOWED'
+  }
+];
+
+console.log('Testing scout-block.sh hook...\n');
+
+const scriptPath = path.join(__dirname, '..', 'scout-block.sh');
+let passed = 0;
+let failed = 0;
+
+for (const test of testCases) {
+  try {
+    const input = JSON.stringify(test.input);
+    const result = execSync(`bash "${scriptPath}"`, {
+      input,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    const actual = 'ALLOWED';
+    const success = actual === test.expected;
+
+    if (success) {
+      console.log(`✓ ${test.name}: ${actual}`);
+      passed++;
+    } else {
+      console.log(`✗ ${test.name}: expected ${test.expected}, got ${actual}`);
+      failed++;
+    }
+  } catch (error) {
+    const actual = error.status === 2 ? 'BLOCKED' : 'ERROR';
+    const success = actual === test.expected;
+
+    if (success) {
+      console.log(`✓ ${test.name}: ${actual}`);
+      passed++;
+    } else {
+      console.log(`✗ ${test.name}: expected ${test.expected}, got ${actual}`);
+      console.log(`  Error: ${error.stderr.toString().trim()}`);
+      failed++;
+    }
+  }
+}
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/dist/.cursor/hooks.yaml

@@ -0,0 +1,28 @@
+# Git Hooks Configuration
+# Run these commands automatically on git events
+# ═══════════════════════════════════════════════════════════════
+
+# Set to true to enable hooks
+enabled: false
+
+# Commands to run before commit
+# Note: These are suggestions for AI, not actual shell commands
+pre_commit:
+  - review:fast    # Quick code review
+  # - test:related  # Run related tests
+
+# Commands to run after merge
+post_merge:
+  - docs:update    # Update documentation
+  # - deps:check   # Check for dependency updates
+
+# Commands to run before push
+pre_push:
+  # - test:all     # Run all tests
+  # - build:check  # Verify build
+
+# ═══════════════════════════════════════════════════════════════
+# To install hooks, run:
+#   Windows: .\scripts\install-hooks.ps1
+#   macOS/Linux: ./scripts/install-hooks.sh
+# ═══════════════════════════════════════════════════════════════

package/dist/.cursor/metadata.json

@@ -0,0 +1,15 @@
+{
+  "version": "1.18.0",
+  "name": "claudekit-engineer",
+  "description": "A comprehensive boilerplate template for building professional software projects with CLI Coding Agents (Cursor and Antigravity).",
+  "buildDate": "2025-12-03T09:30:09.698Z",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/claudekit/claudekit-engineer.git"
+  },
+  "download": {
+    "lastDownloadedAt": null,
+    "downloadedBy": null,
+    "installCount": 0
+  }
+}