@fyow/copilot-everything 1.0.0 → 1.0.2

package/scripts/lib/utils.js

@@ -0,0 +1,368 @@
+/**
+ * Cross-platform utility functions for Claude Code hooks and scripts
+ * Works on Windows, macOS, and Linux
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync, spawnSync } = require('child_process');
+
+// Platform detection
+const isWindows = process.platform === 'win32';
+const isMacOS = process.platform === 'darwin';
+const isLinux = process.platform === 'linux';
+
+/**
+ * Get the user's home directory (cross-platform)
+ */
+function getHomeDir() {
+  return os.homedir();
+}
+
+/**
+ * Get the Claude config directory
+ */
+function getClaudeDir() {
+  return path.join(getHomeDir(), '.claude');
+}
+
+/**
+ * Get the sessions directory
+ */
+function getSessionsDir() {
+  return path.join(getClaudeDir(), 'sessions');
+}
+
+/**
+ * Get the learned skills directory
+ */
+function getLearnedSkillsDir() {
+  return path.join(getClaudeDir(), 'skills', 'learned');
+}
+
+/**
+ * Get the temp directory (cross-platform)
+ */
+function getTempDir() {
+  return os.tmpdir();
+}
+
+/**
+ * Ensure a directory exists (create if not)
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  return dirPath;
+}
+
+/**
+ * Get current date in YYYY-MM-DD format
+ */
+function getDateString() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * Get current time in HH:MM format
+ */
+function getTimeString() {
+  const now = new Date();
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  return `${hours}:${minutes}`;
+}
+
+/**
+ * Get current datetime in YYYY-MM-DD HH:MM:SS format
+ */
+function getDateTimeString() {
+  const now = new Date();
+  const year = now.getFullYear();
+  const month = String(now.getMonth() + 1).padStart(2, '0');
+  const day = String(now.getDate()).padStart(2, '0');
+  const hours = String(now.getHours()).padStart(2, '0');
+  const minutes = String(now.getMinutes()).padStart(2, '0');
+  const seconds = String(now.getSeconds()).padStart(2, '0');
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+
+/**
+ * Find files matching a pattern in a directory (cross-platform alternative to find)
+ * @param {string} dir - Directory to search
+ * @param {string} pattern - File pattern (e.g., "*.tmp", "*.md")
+ * @param {object} options - Options { maxAge: days, recursive: boolean }
+ */
+function findFiles(dir, pattern, options = {}) {
+  const { maxAge = null, recursive = false } = options;
+  const results = [];
+
+  if (!fs.existsSync(dir)) {
+    return results;
+  }
+
+  const regexPattern = pattern
+    .replace(/\./g, '\\.')
+    .replace(/\*/g, '.*')
+    .replace(/\?/g, '.');
+  const regex = new RegExp(`^${regexPattern}$`);
+
+  function searchDir(currentDir) {
+    try {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+
+        if (entry.isFile() && regex.test(entry.name)) {
+          if (maxAge !== null) {
+            const stats = fs.statSync(fullPath);
+            const ageInDays = (Date.now() - stats.mtimeMs) / (1000 * 60 * 60 * 24);
+            if (ageInDays <= maxAge) {
+              results.push({ path: fullPath, mtime: stats.mtimeMs });
+            }
+          } else {
+            const stats = fs.statSync(fullPath);
+            results.push({ path: fullPath, mtime: stats.mtimeMs });
+          }
+        } else if (entry.isDirectory() && recursive) {
+          searchDir(fullPath);
+        }
+      }
+    } catch (err) {
+      // Ignore permission errors
+    }
+  }
+
+  searchDir(dir);
+
+  // Sort by modification time (newest first)
+  results.sort((a, b) => b.mtime - a.mtime);
+
+  return results;
+}
+
+/**
+ * Read JSON from stdin (for hook input)
+ */
+async function readStdinJson() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+      data += chunk;
+    });
+
+    process.stdin.on('end', () => {
+      try {
+        if (data.trim()) {
+          resolve(JSON.parse(data));
+        } else {
+          resolve({});
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+
+    process.stdin.on('error', reject);
+  });
+}
+
+/**
+ * Log to stderr (visible to user in Claude Code)
+ */
+function log(message) {
+  console.error(message);
+}
+
+/**
+ * Output to stdout (returned to Claude)
+ */
+function output(data) {
+  if (typeof data === 'object') {
+    console.log(JSON.stringify(data));
+  } else {
+    console.log(data);
+  }
+}
+
+/**
+ * Read a text file safely
+ */
+function readFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write a text file
+ */
+function writeFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
+/**
+ * Append to a text file
+ */
+function appendFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.appendFileSync(filePath, content, 'utf8');
+}
+
+/**
+ * Check if a command exists in PATH
+ */
+function commandExists(cmd) {
+  try {
+    if (isWindows) {
+      execSync(`where ${cmd}`, { stdio: 'pipe' });
+    } else {
+      execSync(`which ${cmd}`, { stdio: 'pipe' });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Run a command and return output
+ */
+function runCommand(cmd, options = {}) {
+  try {
+    const result = execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...options
+    });
+    return { success: true, output: result.trim() };
+  } catch (err) {
+    return { success: false, output: err.stderr || err.message };
+  }
+}
+
+/**
+ * Check if current directory is a git repository
+ */
+function isGitRepo() {
+  return runCommand('git rev-parse --git-dir').success;
+}
+
+/**
+ * Get git modified files
+ */
+function getGitModifiedFiles(patterns = []) {
+  if (!isGitRepo()) return [];
+
+  const result = runCommand('git diff --name-only HEAD');
+  if (!result.success) return [];
+
+  let files = result.output.split('\n').filter(Boolean);
+
+  if (patterns.length > 0) {
+    files = files.filter(file => {
+      return patterns.some(pattern => {
+        const regex = new RegExp(pattern);
+        return regex.test(file);
+      });
+    });
+  }
+
+  return files;
+}
+
+/**
+ * Replace text in a file (cross-platform sed alternative)
+ */
+function replaceInFile(filePath, search, replace) {
+  const content = readFile(filePath);
+  if (content === null) return false;
+
+  const newContent = content.replace(search, replace);
+  writeFile(filePath, newContent);
+  return true;
+}
+
+/**
+ * Count occurrences of a pattern in a file
+ */
+function countInFile(filePath, pattern) {
+  const content = readFile(filePath);
+  if (content === null) return 0;
+
+  const regex = pattern instanceof RegExp ? pattern : new RegExp(pattern, 'g');
+  const matches = content.match(regex);
+  return matches ? matches.length : 0;
+}
+
+/**
+ * Search for pattern in file and return matching lines with line numbers
+ */
+function grepFile(filePath, pattern) {
+  const content = readFile(filePath);
+  if (content === null) return [];
+
+  const regex = pattern instanceof RegExp ? pattern : new RegExp(pattern);
+  const lines = content.split('\n');
+  const results = [];
+
+  lines.forEach((line, index) => {
+    if (regex.test(line)) {
+      results.push({ lineNumber: index + 1, content: line });
+    }
+  });
+
+  return results;
+}
+
+module.exports = {
+  // Platform info
+  isWindows,
+  isMacOS,
+  isLinux,
+
+  // Directories
+  getHomeDir,
+  getClaudeDir,
+  getSessionsDir,
+  getLearnedSkillsDir,
+  getTempDir,
+  ensureDir,
+
+  // Date/Time
+  getDateString,
+  getTimeString,
+  getDateTimeString,
+
+  // File operations
+  findFiles,
+  readFile,
+  writeFile,
+  appendFile,
+  replaceInFile,
+  countInFile,
+  grepFile,
+
+  // Hook I/O
+  readStdinJson,
+  log,
+  output,
+
+  // System
+  commandExists,
+  runCommand,
+  isGitRepo,
+  getGitModifiedFiles
+};

package/scripts/migrate-to-copilot.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+/**
+ * Migration script to convert Claude Code configs to Copilot CLI format
+ * 
+ * Usage: node scripts/migrate-to-copilot.js [--dry-run]
+ */
+
+const fs = require('fs')
+const path = require('path')
+
+const DRY_RUN = process.argv.includes('--dry-run')
+
+// Tool name mappings from Claude Code to Copilot CLI
+const TOOL_MAPPINGS = {
+  'Read': 'read',
+  'Write': 'edit',
+  'Edit': 'edit',
+  'Bash': 'shell',
+  'Grep': 'search',
+  'Glob': 'search',
+}
+
+// Model mappings
+const MODEL_MAPPINGS = {
+  'opus': 'claude-opus-4-5',
+  'sonnet': 'claude-sonnet-4-5',
+  'haiku': 'claude-haiku-4-5',
+}
+
+function log(message) {
+  console.log(`[migrate] ${message}`)
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    if (!DRY_RUN) {
+      fs.mkdirSync(dirPath, { recursive: true })
+    }
+    log(`Created directory: ${dirPath}`)
+  }
+}
+
+function readMarkdownWithFrontmatter(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8')
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/)
+  
+  if (!match) {
+    return { frontmatter: {}, body: content }
+  }
+  
+  const frontmatterLines = match[1].split('\n')
+  const frontmatter = {}
+  
+  for (const line of frontmatterLines) {
+    const colonIndex = line.indexOf(':')
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim()
+      const value = line.slice(colonIndex + 1).trim()
+      frontmatter[key] = value
+    }
+  }
+  
+  return { frontmatter, body: match[2] }
+}
+
+function convertTools(toolsString) {
+  if (!toolsString) return undefined
+  
+  const tools = toolsString.split(',').map(t => t.trim())
+  const converted = tools.map(t => TOOL_MAPPINGS[t] || t.toLowerCase())
+  
+  // Remove duplicates
+  return [...new Set(converted)]
+}
+
+function convertAgent(sourcePath, destPath) {
+  const { frontmatter, body } = readMarkdownWithFrontmatter(sourcePath)
+  
+  const newFrontmatter = {
+    name: frontmatter.name,
+    description: frontmatter.description,
+  }
+  
+  // Convert tools
+  const tools = convertTools(frontmatter.tools)
+  if (tools && tools.length > 0) {
+    newFrontmatter.tools = JSON.stringify(tools)
+  }
+  
+  // Build new content
+  let newContent = '---\n'
+  newContent += `name: ${newFrontmatter.name}\n`
+  newContent += `description: ${newFrontmatter.description}\n`
+  if (tools) {
+    newContent += `tools: ${JSON.stringify(tools)}\n`
+  }
+  newContent += '---\n\n'
+  newContent += body
+  
+  if (!DRY_RUN) {
+    ensureDir(path.dirname(destPath))
+    fs.writeFileSync(destPath, newContent)
+  }
+  
+  log(`Converted agent: ${path.basename(sourcePath)} → ${path.basename(destPath)}`)
+}
+
+function convertRule(sourcePath, destPath, applyTo = '**') {
+  const content = fs.readFileSync(sourcePath, 'utf8')
+  
+  // Add frontmatter with applyTo
+  let newContent = '---\n'
+  newContent += `applyTo: "${applyTo}"\n`
+  newContent += '---\n\n'
+  newContent += content
+  
+  if (!DRY_RUN) {
+    ensureDir(path.dirname(destPath))
+    fs.writeFileSync(destPath, newContent)
+  }
+  
+  log(`Converted rule: ${path.basename(sourcePath)} → ${path.basename(destPath)}`)
+}
+
+function convertHooks(sourcePath, destPath) {
+  const content = JSON.parse(fs.readFileSync(sourcePath, 'utf8'))
+  
+  const newHooks = {
+    version: 1,
+    hooks: {}
+  }
+  
+  // Map hook types
+  const hookTypeMap = {
+    'PreToolUse': 'preToolUse',
+    'PostToolUse': 'postToolUse',
+    'SessionStart': 'sessionStart',
+    'SessionEnd': 'sessionEnd',
+    'Stop': 'sessionEnd',
+    'PreCompact': 'preToolUse',
+  }
+  
+  for (const [oldType, hooks] of Object.entries(content.hooks || {})) {
+    const newType = hookTypeMap[oldType]
+    if (!newType) continue
+    
+    if (!newHooks.hooks[newType]) {
+      newHooks.hooks[newType] = []
+    }
+    
+    for (const hook of hooks) {
+      // Extract command from hook
+      let command = ''
+      if (hook.hooks && hook.hooks[0]) {
+        command = hook.hooks[0].command
+      } else if (hook.command) {
+        command = hook.command
+      }
+      
+      if (!command) continue
+      
+      newHooks.hooks[newType].push({
+        type: 'command',
+        bash: command,
+        powershell: command,
+        cwd: '.',
+        timeoutSec: 30
+      })
+    }
+  }
+  
+  if (!DRY_RUN) {
+    ensureDir(path.dirname(destPath))
+    fs.writeFileSync(destPath, JSON.stringify(newHooks, null, 2))
+  }
+  
+  log(`Converted hooks: ${path.basename(sourcePath)} → ${path.basename(destPath)}`)
+}
+
+function main() {
+  const projectRoot = path.resolve(__dirname, '..')
+  
+  log('Starting migration to Copilot CLI format...')
+  if (DRY_RUN) {
+    log('DRY RUN - no files will be modified')
+  }
+  
+  // Create directories
+  ensureDir(path.join(projectRoot, '.github', 'agents'))
+  ensureDir(path.join(projectRoot, '.github', 'skills'))
+  ensureDir(path.join(projectRoot, '.github', 'instructions'))
+  ensureDir(path.join(projectRoot, '.github', 'hooks'))
+  ensureDir(path.join(projectRoot, 'copilot'))
+  
+  // Convert agents
+  const agentsDir = path.join(projectRoot, 'agents')
+  if (fs.existsSync(agentsDir)) {
+    for (const file of fs.readdirSync(agentsDir)) {
+      if (file.endsWith('.md')) {
+        const name = file.replace('.md', '')
+        convertAgent(
+          path.join(agentsDir, file),
+          path.join(projectRoot, '.github', 'agents', `${name}.agent.md`)
+        )
+      }
+    }
+  }
+  
+  // Convert rules to instructions
+  const rulesDir = path.join(projectRoot, 'rules')
+  const rulePatterns = {
+    'security.md': '**/*.ts,**/*.tsx,**/*.js,**/*.jsx',
+    'coding-style.md': '**/*.ts,**/*.tsx,**/*.js,**/*.jsx',
+    'testing.md': '**/*.test.ts,**/*.test.tsx,**/*.spec.ts,**/*.spec.tsx',
+    'git-workflow.md': '**',
+    'performance.md': '**',
+  }
+  
+  if (fs.existsSync(rulesDir)) {
+    for (const file of fs.readdirSync(rulesDir)) {
+      if (file.endsWith('.md')) {
+        const name = file.replace('.md', '')
+        const applyTo = rulePatterns[file] || '**'
+        convertRule(
+          path.join(rulesDir, file),
+          path.join(projectRoot, '.github', 'instructions', `${name}.instructions.md`),
+          applyTo
+        )
+      }
+    }
+  }
+  
+  // Note: Skills are already compatible format, just need to be copied
+  log('Skills are already in compatible format (.github/skills/*/SKILL.md)')
+  
+  log('')
+  log('Migration complete!')
+  log('')
+  log('Next steps:')
+  log('1. Review generated files in .github/')
+  log('2. Copy copilot/mcp-config.json to ~/.copilot/')
+  log('3. Test with: copilot')
+  log('4. Use /agent to see available agents')
+}
+
+main()