anchi-kit 1.2.0 → 1.2.2

package/.cursor/hooks/telegram_notify.sh

@@ -1,158 +0,0 @@
-#!/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/.cursor/hooks/tests/test-ckignore.js

@@ -1,194 +0,0 @@
-#!/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/.cursor/hooks/tests/test-modularization-hook.js

@@ -1,126 +0,0 @@
-#!/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/.cursor/hooks/tests/test-scout-block.js

@@ -1,125 +0,0 @@
-#!/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/.cursor/hooks.yaml

@@ -1,28 +0,0 @@
-# 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/.cursor/metadata.json

@@ -1,15 +0,0 @@
-{
-  "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
-  }
-}