@codemieai/code 0.0.33 → 0.0.35

package/scripts/copy-mr-skill-to-global.ts

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+/**
+ * Copy /mr skill from project scope to global scope
+ *
+ * This script copies the project-level /mr skill to ~/.claude/skills/mr/
+ * making it available globally across all projects.
+ *
+ * Usage:
+ *   npm run build && node dist/scripts/copy-mr-skill-to-global.js
+ *   OR
+ *   npx tsx scripts/copy-mr-skill-to-global.ts
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { parseFrontmatter } from '../src/skills/utils/frontmatter.js';
+import { SkillMetadataSchema } from '../src/skills/core/types.js';
+import { resolveHomeDir } from '../src/utils/paths.js';
+import { SkillManager } from '../src/skills/index.js';
+import * as readline from 'readline';
+
+interface CopyResult {
+  success: boolean;
+  message: string;
+  copiedFiles?: string[];
+}
+
+/**
+ * Validate source skill exists and has valid frontmatter
+ */
+async function validateSourceSkill(sourceDir: string): Promise<void> {
+  const skillPath = path.join(sourceDir, 'SKILL.md');
+
+  // Check file exists
+  try {
+    await fs.access(skillPath, fs.constants.R_OK);
+  } catch {
+    throw new Error(`Source skill not found: ${skillPath}`);
+  }
+
+  // Validate frontmatter
+  const content = await fs.readFile(skillPath, 'utf-8');
+  const { metadata } = parseFrontmatter(content, skillPath);
+  const validated = SkillMetadataSchema.parse(metadata);
+
+  console.log(`✓ Source skill validated: ${validated.name}`);
+  console.log(`  Description: ${validated.description}`);
+}
+
+/**
+ * Check if target already exists and prompt user for overwrite
+ */
+async function checkTargetConflict(targetDir: string): Promise<void> {
+  const targetSkillPath = path.join(targetDir, 'SKILL.md');
+
+  try {
+    await fs.access(targetSkillPath, fs.constants.F_OK);
+
+    // File exists - prompt user
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer = await new Promise<string>((resolve) => {
+      rl.question(
+        `\n⚠️  Global /mr skill already exists. Overwrite? (y/N): `,
+        resolve
+      );
+    });
+
+    rl.close();
+
+    if (answer.toLowerCase() !== 'y') {
+      console.log('❌ Operation cancelled by user');
+      process.exit(0);
+    }
+
+    // Create backup before overwriting
+    const backupDir = `${targetDir}.backup-${Date.now()}`;
+    await fs.rename(targetDir, backupDir);
+    console.log(`✓ Backup created: ${backupDir}`);
+  } catch {
+    // File doesn't exist - proceed
+    console.log('✓ No conflict detected');
+  }
+}
+
+/**
+ * Create necessary directories for the skill
+ */
+async function prepareDirectories(targetDir: string): Promise<void> {
+  // Create main directory
+  await fs.mkdir(targetDir, { recursive: true });
+
+  // Create references subdirectory
+  const refsDir = path.join(targetDir, 'references');
+  await fs.mkdir(refsDir, { recursive: true });
+
+  console.log(`✓ Directories created: ${targetDir}`);
+}
+
+/**
+ * Copy all skill files from source to target
+ */
+async function copySkillFiles(
+  sourceDir: string,
+  targetDir: string
+): Promise<string[]> {
+  const filesToCopy = [
+    { source: 'SKILL.md', target: 'SKILL.md' },
+    { source: 'references/branch-naming.md', target: 'references/branch-naming.md' },
+    { source: 'references/examples.md', target: 'references/examples.md' },
+  ];
+
+  const copiedFiles: string[] = [];
+
+  for (const { source, target } of filesToCopy) {
+    const sourcePath = path.join(sourceDir, source);
+    const targetPath = path.join(targetDir, target);
+
+    // Ensure subdirectory exists
+    const targetSubdir = path.dirname(targetPath);
+    await fs.mkdir(targetSubdir, { recursive: true });
+
+    // Copy file
+    await fs.copyFile(sourcePath, targetPath);
+    copiedFiles.push(source);
+
+    console.log(`✓ Copied: ${source}`);
+  }
+
+  return copiedFiles;
+}
+
+/**
+ * Validate the copied skill has valid frontmatter
+ */
+async function validateCopiedSkill(skillPath: string): Promise<void> {
+  // Verify file exists
+  await fs.access(skillPath, fs.constants.R_OK);
+
+  // Validate frontmatter
+  const content = await fs.readFile(skillPath, 'utf-8');
+  const { metadata } = parseFrontmatter(content, skillPath);
+  SkillMetadataSchema.parse(metadata);
+
+  console.log(`✓ Copied skill validated successfully`);
+}
+
+/**
+ * Test that the skill is discoverable by SkillManager
+ */
+async function testDiscovery(): Promise<void> {
+  const manager = SkillManager.getInstance();
+  manager.reload(); // Clear cache
+
+  const skills = await manager.listSkills({
+    cwd: process.cwd(),
+    forceReload: true,
+  });
+
+  const mrSkills = skills.filter(s => s.metadata.name === 'mr');
+
+  if (mrSkills.length > 0) {
+    console.log(`✓ Skill discoverable (${mrSkills.length} instance(s) found)`);
+    mrSkills.forEach(skill => {
+      console.log(`  Source: ${skill.source}`);
+      console.log(`  Priority: ${skill.computedPriority}`);
+      console.log(`  Path: ${skill.filePath}`);
+    });
+  } else {
+    console.warn('⚠️  Skill not immediately discoverable (may need agent restart)');
+  }
+}
+
+/**
+ * Print success message with next steps
+ */
+function printSuccess(targetDir: string, files: string[]): void {
+  console.log('\n' + '='.repeat(60));
+  console.log('✅ Successfully copied /mr skill to global scope!');
+  console.log('='.repeat(60));
+  console.log(`\n📁 Location: ${targetDir}`);
+  console.log(`📄 Files copied: ${files.length}`);
+  console.log(`\n🔄 Next steps:`);
+  console.log(`1. The skill is now available globally across all projects`);
+  console.log(`2. Use /mr in any project to create pull requests`);
+  console.log(`3. Run "codemie skill list" to verify it's loaded`);
+  console.log(`4. Run "codemie skill reload" to refresh if needed`);
+  console.log(`\n💡 Tip: Project-level skills (if present) take priority over global skills.\n`);
+}
+
+/**
+ * Print error message with troubleshooting tips
+ */
+function printError(error: unknown): void {
+  console.error('\n' + '='.repeat(60));
+  console.error('❌ Failed to copy /mr skill');
+  console.error('='.repeat(60));
+  console.error(`\nError: ${error instanceof Error ? error.message : String(error)}`);
+  if (error instanceof Error && error.stack) {
+    console.error(`\nStack trace:\n${error.stack}`);
+  }
+  console.error(`\n🔍 Troubleshooting:`);
+  console.error(`- Check source exists: .codemie/skills/mr/SKILL.md`);
+  console.error(`- Check permissions: ~/.claude/skills/`);
+  console.error(`- Check disk space: df -h ~`);
+  console.error(`- Validate frontmatter: codemie skill validate\n`);
+}
+
+/**
+ * Main execution function
+ */
+async function main(): Promise<void> {
+  try {
+    console.log('\n🚀 Starting /mr skill copy to global scope...\n');
+
+    // Phase 1: Validate source
+    console.log('Phase 1: Validating source skill...');
+    const sourceDir = path.join(process.cwd(), '.codemie', 'skills', 'mr');
+    await validateSourceSkill(sourceDir);
+
+    // Phase 2: Check target
+    console.log('\nPhase 2: Checking target location...');
+    const targetDir = resolveHomeDir('.claude/skills/mr');
+    await checkTargetConflict(targetDir);
+
+    // Phase 3: Prepare directories
+    console.log('\nPhase 3: Preparing directories...');
+    await prepareDirectories(targetDir);
+
+    // Phase 4: Copy files
+    console.log('\nPhase 4: Copying skill files...');
+    const files = await copySkillFiles(sourceDir, targetDir);
+
+    // Phase 5: Validate
+    console.log('\nPhase 5: Validating copied skill...');
+    await validateCopiedSkill(path.join(targetDir, 'SKILL.md'));
+    await testDiscovery();
+
+    // Phase 6: Success feedback
+    printSuccess(targetDir, files);
+  } catch (error) {
+    printError(error);
+    process.exit(1);
+  }
+}
+
+// Run main function
+main();

package/scripts/demo-hooks.sh

@@ -0,0 +1,125 @@
+#!/bin/bash
+# Demo script for testing hooks in codemie-code
+
+set -e
+
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}   CodeMie Hooks Demo${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# Check if config exists
+if [ ! -f ~/.codemie/codemie-cli.config.json ]; then
+    echo -e "${RED}✗ Configuration file not found${NC}"
+    exit 1
+fi
+
+# Show configured hooks
+echo -e "${GREEN}✓ Configuration loaded${NC}"
+echo ""
+echo "Configured Hooks:"
+echo "━━━━━━━━━━━━━━━━"
+
+# PreToolUse
+echo -e "${YELLOW}PreToolUse:${NC}"
+echo "  • Matcher: Bash"
+echo "  • Action: Block 'rm -rf' commands"
+echo "  • Script: ~/.codemie/test-hooks/pre-tool-hook.sh"
+
+echo ""
+echo -e "${YELLOW}PostToolUse:${NC}"
+echo "  • Matcher: * (all tools)"
+echo "  • Action: Log all tool usage"
+echo "  • Script: ~/.codemie/test-hooks/post-tool-hook.sh"
+
+echo ""
+echo -e "${YELLOW}UserPromptSubmit:${NC}"
+echo "  • Action: Add context to prompts"
+echo "  • Script: ~/.codemie/test-hooks/prompt-hook.sh"
+
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# Clear logs for clean test
+rm -f ~/.codemie/hook-test.log
+rm -f ~/.codemie/tool-usage.log
+echo -e "${GREEN}✓ Logs cleared for clean test${NC}"
+echo ""
+
+# Show test scenarios
+echo -e "${BLUE}Test Scenarios:${NC}"
+echo "━━━━━━━━━━━━━━━━"
+echo ""
+
+echo -e "${YELLOW}Scenario 1: PreToolUse Hook Blocks Dangerous Command${NC}"
+echo "  Try: \"run the command: rm -rf /tmp/test\""
+echo "  Expected: Hook blocks it with error"
+echo ""
+
+echo -e "${YELLOW}Scenario 2: PreToolUse Hook Allows Safe Command${NC}"
+echo "  Try: \"run the command: echo 'Hello World'\""
+echo "  Expected: Command executes normally"
+echo ""
+
+echo -e "${YELLOW}Scenario 3: PostToolUse Hook Logs Tools${NC}"
+echo "  Try: \"read package.json and show me the name\""
+echo "  Expected: Tool usage logged to ~/.codemie/tool-usage.log"
+echo ""
+
+echo -e "${YELLOW}Scenario 4: UserPromptSubmit Hook Adds Context${NC}"
+echo "  Try any prompt and check if context is added"
+echo "  Expected: Agent has context about working directory"
+echo ""
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+echo -e "${GREEN}Monitoring:${NC}"
+echo "  Watch hooks in real-time:"
+echo "  ${BLUE}tail -f ~/.codemie/logs/debug-\$(date +%Y-%m-%d).log | grep -i hook${NC}"
+echo ""
+echo "  Check hook logs after test:"
+echo "  ${BLUE}cat ~/.codemie/hook-test.log${NC}"
+echo "  ${BLUE}cat ~/.codemie/tool-usage.log${NC}"
+echo ""
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# Ask if user wants to set API key
+echo -e "${YELLOW}⚠ Important: You need a valid API key to run codemie-code${NC}"
+echo ""
+echo "Options:"
+echo "  1. Set CODEMIE_API_KEY environment variable"
+echo "  2. Update ~/.codemie/codemie-cli.config.json with your key"
+echo "  3. Run: codemie setup"
+echo ""
+
+read -p "Do you have an API key configured? (y/n) " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo ""
+    echo -e "${YELLOW}Please configure your API key first:${NC}"
+    echo "  export CODEMIE_API_KEY='your-key-here'"
+    echo ""
+    echo "Then run:"
+    echo "  ${BLUE}codemie-code${NC}"
+    echo ""
+    exit 0
+fi
+
+echo ""
+echo -e "${GREEN}Starting codemie-code with hooks enabled...${NC}"
+echo ""
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo ""
+
+# Start codemie-code
+codemie-code

package/scripts/test-hooks.sh

@@ -0,0 +1,196 @@
+#!/bin/bash
+# Quick Hooks System Test Script
+# Tests the hooks implementation with example scenarios
+
+set -e
+
+HOOKS_DIR="$HOME/.codemie/test-hooks"
+LOG_FILE="$HOME/.codemie/hook-test.log"
+TEST_CONFIG="$HOME/.codemie/test-hooks-config.json"
+
+echo "🧪 CodeMie Hooks System Test"
+echo "=============================="
+echo ""
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Check if jq is installed
+if ! command -v jq &> /dev/null; then
+    echo -e "${RED}✗ Error: jq is required but not installed${NC}"
+    echo "Install with: brew install jq (macOS) or apt-get install jq (Linux)"
+    exit 1
+fi
+
+# Create test hooks directory
+echo "📁 Setting up test environment..."
+mkdir -p "$HOOKS_DIR"
+
+# Create PreToolUse hook (blocks rm -rf)
+cat > "$HOOKS_DIR/pre-tool-hook.sh" << 'EOF'
+#!/bin/bash
+TOOL_NAME=$(echo "$CODEMIE_HOOK_INPUT" | jq -r '.tool_name')
+echo "[PreToolUse] Tool: $TOOL_NAME" >> ~/.codemie/hook-test.log
+
+if [[ "$TOOL_NAME" == "Bash" ]]; then
+  COMMAND=$(echo "$CODEMIE_HOOK_INPUT" | jq -r '.tool_input.command')
+  if [[ "$COMMAND" =~ "rm -rf" ]]; then
+    echo '{"decision": "block", "reason": "Dangerous command blocked: rm -rf"}'
+    exit 0
+  fi
+fi
+
+echo '{"decision": "allow"}'
+exit 0
+EOF
+
+# Create PostToolUse hook (logs all usage)
+cat > "$HOOKS_DIR/post-tool-hook.sh" << 'EOF'
+#!/bin/bash
+TOOL_NAME=$(echo "$CODEMIE_HOOK_INPUT" | jq -r '.tool_name')
+TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
+echo "[$TIMESTAMP] Tool: $TOOL_NAME" >> ~/.codemie/tool-usage.log
+echo '{"decision": "allow"}'
+exit 0
+EOF
+
+# Create UserPromptSubmit hook (adds context)
+cat > "$HOOKS_DIR/prompt-hook.sh" << 'EOF'
+#!/bin/bash
+echo "{
+  \"decision\": \"allow\",
+  \"additionalContext\": \"Test context: Working in $(pwd)\"
+}"
+exit 0
+EOF
+
+# Make scripts executable
+chmod +x "$HOOKS_DIR"/*.sh
+
+echo -e "${GREEN}✓ Test hooks created${NC}"
+echo ""
+
+# Run tests
+echo "🧪 Running Hook Tests..."
+echo "----------------------"
+
+# Clear logs
+rm -f "$LOG_FILE" "$HOME/.codemie/tool-usage.log"
+
+# Test 1: PreToolUse allows safe commands
+echo -n "Test 1: PreToolUse allows safe commands... "
+export CODEMIE_HOOK_INPUT='{"hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{"command":"ls -la"},"session_id":"test","cwd":"'$(pwd)'"}'
+RESULT=$("$HOOKS_DIR/pre-tool-hook.sh")
+EXIT_CODE=$?
+
+if [[ $EXIT_CODE -eq 0 ]] && echo "$RESULT" | jq -e '.decision == "allow"' > /dev/null 2>&1; then
+    echo -e "${GREEN}✓ PASS${NC}"
+else
+    echo -e "${RED}✗ FAIL${NC}"
+    echo "  Expected: allow, Got: $RESULT"
+fi
+
+# Test 2: PreToolUse blocks dangerous commands
+echo -n "Test 2: PreToolUse blocks dangerous commands... "
+export CODEMIE_HOOK_INPUT='{"hook_event_name":"PreToolUse","tool_name":"Bash","tool_input":{"command":"rm -rf /test"},"session_id":"test","cwd":"'$(pwd)'"}'
+RESULT=$("$HOOKS_DIR/pre-tool-hook.sh")
+EXIT_CODE=$?
+
+if [[ $EXIT_CODE -eq 0 ]] && echo "$RESULT" | jq -e '.decision == "block"' > /dev/null 2>&1; then
+    echo -e "${GREEN}✓ PASS${NC}"
+else
+    echo -e "${RED}✗ FAIL${NC}"
+    echo "  Expected: block, Got: $RESULT"
+fi
+
+# Test 3: PreToolUse blocks specific tool
+echo -n "Test 3: PreToolUse logs to file... "
+if [ -f "$LOG_FILE" ] && grep -q "PreToolUse" "$LOG_FILE"; then
+    echo -e "${GREEN}✓ PASS${NC}"
+else
+    echo -e "${RED}✗ FAIL${NC}"
+    echo "  Expected log file with PreToolUse entries"
+fi
+
+# Test 4: PostToolUse creates logs
+echo -n "Test 4: PostToolUse creates usage logs... "
+export CODEMIE_HOOK_INPUT='{"hook_event_name":"PostToolUse","tool_name":"Read","session_id":"test","cwd":"'$(pwd)'"}'
+RESULT=$("$HOOKS_DIR/post-tool-hook.sh")
+
+if [ -f "$HOME/.codemie/tool-usage.log" ] && grep -q "Tool: Read" "$HOME/.codemie/tool-usage.log"; then
+    echo -e "${GREEN}✓ PASS${NC}"
+else
+    echo -e "${RED}✗ FAIL${NC}"
+    echo "  Expected usage log with Read entry"
+fi
+
+# Test 5: UserPromptSubmit adds context
+echo -n "Test 5: UserPromptSubmit adds context... "
+export CODEMIE_HOOK_INPUT='{"hook_event_name":"UserPromptSubmit","prompt":"test prompt","session_id":"test","cwd":"'$(pwd)'"}'
+RESULT=$("$HOOKS_DIR/prompt-hook.sh")
+
+if echo "$RESULT" | jq -e '.additionalContext != null' > /dev/null 2>&1; then
+    echo -e "${GREEN}✓ PASS${NC}"
+else
+    echo -e "${RED}✗ FAIL${NC}"
+    echo "  Expected additionalContext in result"
+fi
+
+# Test 6: Hook JSON output is valid
+echo -n "Test 6: Hook output is valid JSON... "
+export CODEMIE_HOOK_INPUT='{"hook_event_name":"PreToolUse","tool_name":"Test","session_id":"test","cwd":"'$(pwd)'"}'
+RESULT=$("$HOOKS_DIR/pre-tool-hook.sh")
+
+if echo "$RESULT" | jq '.' > /dev/null 2>&1; then
+    echo -e "${GREEN}✓ PASS${NC}"
+else
+    echo -e "${RED}✗ FAIL${NC}"
+    echo "  Hook output is not valid JSON: $RESULT"
+fi
+
+# Test 7: Hook execution time
+echo -n "Test 7: Hook performance (< 100ms)... "
+export CODEMIE_HOOK_INPUT='{"hook_event_name":"PreToolUse","tool_name":"Test","session_id":"test","cwd":"'$(pwd)'"}'
+START=$(date +%s%N)
+"$HOOKS_DIR/pre-tool-hook.sh" > /dev/null
+END=$(date +%s%N)
+DURATION=$(( ($END - $START) / 1000000 )) # Convert to milliseconds
+
+if [ $DURATION -lt 100 ]; then
+    echo -e "${GREEN}✓ PASS${NC} (${DURATION}ms)"
+else
+    echo -e "${YELLOW}⚠ SLOW${NC} (${DURATION}ms)"
+fi
+
+echo ""
+echo "📊 Test Summary"
+echo "----------------------"
+echo "Test hooks created at: $HOOKS_DIR"
+echo "Logs created at:"
+echo "  - $LOG_FILE"
+echo "  - $HOME/.codemie/tool-usage.log"
+echo ""
+echo -e "${YELLOW}Next Steps:${NC}"
+echo "1. Review test hooks: ls -la $HOOKS_DIR"
+echo "2. Check logs: cat $LOG_FILE"
+echo "3. View full testing guide: docs/HOOKS_TESTING.md"
+echo "4. Configure hooks in your profile: ~/.codemie/codemie-cli.config.json"
+echo ""
+echo "Example configuration:"
+echo '  "hooks": {'
+echo '    "PreToolUse": ['
+echo '      {'
+echo '        "matcher": "Bash",'
+echo '        "hooks": [{'
+echo '          "type": "command",'
+echo "          \"command\": \"$HOOKS_DIR/pre-tool-hook.sh\","
+echo '          "timeout": 5000'
+echo '        }]'
+echo '      }'
+echo '    ]'
+echo '  }'
+echo ""
+echo -e "${GREEN}✓ All basic tests passed!${NC}"