@fyow/copilot-everything 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fyow/copilot-everything",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Everything you need for GitHub Copilot CLI - agents, skills, instructions, and hooks configurations",
   "main": "src/index.js",
   "bin": {
@@ -12,6 +12,7 @@
   "files": [
     "src/",
     ".github/",
+    "scripts/",
     "AGENTS.md",
     "copilot/"
   ],

package/scripts/hooks/evaluate-session.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Continuous Learning - Session Evaluator
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs on Stop hook to extract reusable patterns from Claude Code sessions
+ *
+ * Why Stop hook instead of UserPromptSubmit:
+ * - Stop runs once at session end (lightweight)
+ * - UserPromptSubmit runs every message (heavy, adds latency)
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getLearnedSkillsDir,
+  ensureDir,
+  readFile,
+  countInFile,
+  log
+} = require('../lib/utils');
+
+async function main() {
+  // Get script directory to find config
+  const scriptDir = __dirname;
+  const configFile = path.join(scriptDir, '..', '..', 'skills', 'continuous-learning', 'config.json');
+
+  // Default configuration
+  let minSessionLength = 10;
+  let learnedSkillsPath = getLearnedSkillsDir();
+
+  // Load config if exists
+  const configContent = readFile(configFile);
+  if (configContent) {
+    try {
+      const config = JSON.parse(configContent);
+      minSessionLength = config.min_session_length || 10;
+
+      if (config.learned_skills_path) {
+        // Handle ~ in path
+        learnedSkillsPath = config.learned_skills_path.replace(/^~/, require('os').homedir());
+      }
+    } catch {
+      // Invalid config, use defaults
+    }
+  }
+
+  // Ensure learned skills directory exists
+  ensureDir(learnedSkillsPath);
+
+  // Get transcript path from environment (set by Claude Code)
+  const transcriptPath = process.env.CLAUDE_TRANSCRIPT_PATH;
+
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    process.exit(0);
+  }
+
+  // Count user messages in session
+  const messageCount = countInFile(transcriptPath, /"type":"user"/g);
+
+  // Skip short sessions
+  if (messageCount < minSessionLength) {
+    log(`[ContinuousLearning] Session too short (${messageCount} messages), skipping`);
+    process.exit(0);
+  }
+
+  // Signal to Claude that session should be evaluated for extractable patterns
+  log(`[ContinuousLearning] Session has ${messageCount} messages - evaluate for extractable patterns`);
+  log(`[ContinuousLearning] Save learned skills to: ${learnedSkillsPath}`);
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[ContinuousLearning] Error:', err.message);
+  process.exit(0);
+});

package/scripts/hooks/post-tool-use.ps1

@@ -0,0 +1,55 @@
+# Post tool use hook for Copilot CLI (PowerShell version)
+# Handles formatting, type checking, and warnings after tool execution
+
+param()
+
+$input = $input | Out-String
+
+try {
+    $data = $input | ConvertFrom-Json
+    $toolName = $data.tool_name
+    $filePath = $data.tool_input.file_path
+} catch {
+    $toolName = ""
+    $filePath = ""
+}
+
+# If editing JS/TS file, run prettier
+if ($filePath -match '\.(ts|tsx|js|jsx)$' -and (Test-Path $filePath)) {
+    try {
+        npx prettier --write $filePath 2>$null
+    } catch {
+        # Ignore prettier errors
+    }
+}
+
+# If editing TS file, run type check
+if ($filePath -match '\.(ts|tsx)$' -and (Test-Path $filePath)) {
+    $dir = Split-Path $filePath -Parent
+    while ($dir -ne "" -and -not (Test-Path "$dir\tsconfig.json")) {
+        $dir = Split-Path $dir -Parent
+    }
+    
+    if (Test-Path "$dir\tsconfig.json") {
+        try {
+            $errors = npx tsc --noEmit --pretty false 2>&1 | Select-String $filePath | Select-Object -First 5
+            if ($errors) {
+                Write-Host "[Hook] TypeScript errors in $filePath`:" -ForegroundColor Yellow
+                $errors | ForEach-Object { Write-Host $_.Line -ForegroundColor Yellow }
+            }
+        } catch {
+            # Ignore tsc errors
+        }
+    }
+}
+
+# Check for console.log in modified files
+if ($filePath -match '\.(ts|tsx|js|jsx)$' -and (Test-Path $filePath)) {
+    $consoleLogLines = Select-String -Path $filePath -Pattern "console\.log" | Select-Object -First 3
+    if ($consoleLogLines) {
+        Write-Host "[Hook] WARNING: console.log found in $filePath - remove before commit" -ForegroundColor Yellow
+    }
+}
+
+# Output original input unchanged
+Write-Output $input

package/scripts/hooks/post-tool-use.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+# Post tool use hook for Copilot CLI
+# Handles formatting, type checking, and warnings after tool execution
+
+set -e
+
+# Read JSON input from stdin
+input=$(cat)
+
+# Extract tool information
+tool_name=$(echo "$input" | node -e "
+  let d='';
+  process.stdin.on('data',c=>d+=c);
+  process.stdin.on('end',()=>{
+    try {
+      const data = JSON.parse(d);
+      console.log(data.tool_name || data.tool || '');
+    } catch(e) {
+      console.log('');
+    }
+  });
+" <<< "$input" 2>/dev/null || echo "")
+
+file_path=$(echo "$input" | node -e "
+  let d='';
+  process.stdin.on('data',c=>d+=c);
+  process.stdin.on('end',()=>{
+    try {
+      const data = JSON.parse(d);
+      console.log(data.tool_input?.file_path || data.file_path || '');
+    } catch(e) {
+      console.log('');
+    }
+  });
+" <<< "$input" 2>/dev/null || echo "")
+
+# If editing JS/TS file, run prettier
+if [[ "$file_path" =~ \.(ts|tsx|js|jsx)$ ]] && [ -f "$file_path" ]; then
+  if command -v npx &> /dev/null; then
+    npx prettier --write "$file_path" 2>/dev/null || true
+  fi
+fi
+
+# If editing TS file, run type check
+if [[ "$file_path" =~ \.(ts|tsx)$ ]] && [ -f "$file_path" ]; then
+  dir=$(dirname "$file_path")
+  while [ "$dir" != "/" ] && [ ! -f "$dir/tsconfig.json" ]; do
+    dir=$(dirname "$dir")
+  done
+  
+  if [ -f "$dir/tsconfig.json" ]; then
+    errors=$(npx tsc --noEmit --pretty false 2>&1 | grep "$file_path" | head -5 || true)
+    if [ -n "$errors" ]; then
+      echo "[Hook] TypeScript errors in $file_path:" >&2
+      echo "$errors" >&2
+    fi
+  fi
+fi
+
+# Check for console.log in modified files
+if [[ "$file_path" =~ \.(ts|tsx|js|jsx)$ ]] && [ -f "$file_path" ]; then
+  if grep -n "console.log" "$file_path" 2>/dev/null | head -3; then
+    echo "[Hook] WARNING: console.log found in $file_path - remove before commit" >&2
+  fi
+fi
+
+# Output original input unchanged
+echo "$input"

package/scripts/hooks/pre-compact.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * PreCompact Hook - Save state before context compaction
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs before Claude compacts context, giving you a chance to
+ * preserve important state that might get lost in summarization.
+ */
+
+const path = require('path');
+const {
+  getSessionsDir,
+  getDateTimeString,
+  getTimeString,
+  findFiles,
+  ensureDir,
+  appendFile,
+  log
+} = require('../lib/utils');
+
+async function main() {
+  const sessionsDir = getSessionsDir();
+  const compactionLog = path.join(sessionsDir, 'compaction-log.txt');
+
+  ensureDir(sessionsDir);
+
+  // Log compaction event with timestamp
+  const timestamp = getDateTimeString();
+  appendFile(compactionLog, `[${timestamp}] Context compaction triggered\n`);
+
+  // If there's an active session file, note the compaction
+  const sessions = findFiles(sessionsDir, '*.tmp');
+
+  if (sessions.length > 0) {
+    const activeSession = sessions[0].path;
+    const timeStr = getTimeString();
+    appendFile(activeSession, `\n---\n**[Compaction occurred at ${timeStr}]** - Context was summarized\n`);
+  }
+
+  log('[PreCompact] State saved before compaction');
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[PreCompact] Error:', err.message);
+  process.exit(0);
+});

package/scripts/hooks/session-end.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+/**
+ * Stop Hook (Session End) - Persist learnings when session ends
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs when Claude session ends. Creates/updates session log file
+ * with timestamp for continuity tracking.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getSessionsDir,
+  getDateString,
+  getTimeString,
+  ensureDir,
+  readFile,
+  writeFile,
+  replaceInFile,
+  log
+} = require('../lib/utils');
+
+async function main() {
+  const sessionsDir = getSessionsDir();
+  const today = getDateString();
+  const sessionFile = path.join(sessionsDir, `${today}-session.tmp`);
+
+  ensureDir(sessionsDir);
+
+  const currentTime = getTimeString();
+
+  // If session file exists for today, update the end time
+  if (fs.existsSync(sessionFile)) {
+    const success = replaceInFile(
+      sessionFile,
+      /\*\*Last Updated:\*\*.*/,
+      `**Last Updated:** ${currentTime}`
+    );
+
+    if (success) {
+      log(`[SessionEnd] Updated session file: ${sessionFile}`);
+    }
+  } else {
+    // Create new session file with template
+    const template = `# Session: ${today}
+**Date:** ${today}
+**Started:** ${currentTime}
+**Last Updated:** ${currentTime}
+
+---
+
+## Current State
+
+[Session context goes here]
+
+### Completed
+- [ ]
+
+### In Progress
+- [ ]
+
+### Notes for Next Session
+-
+
+### Context to Load
+\`\`\`
+[relevant files]
+\`\`\`
+`;
+
+    writeFile(sessionFile, template);
+    log(`[SessionEnd] Created session file: ${sessionFile}`);
+  }
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[SessionEnd] Error:', err.message);
+  process.exit(0);
+});

package/scripts/hooks/session-start.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * SessionStart Hook - Load previous context on new session
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs when a new Claude session starts. Checks for recent session
+ * files and notifies Claude of available context to load.
+ */
+
+const path = require('path');
+const {
+  getSessionsDir,
+  getLearnedSkillsDir,
+  findFiles,
+  ensureDir,
+  log
+} = require('../lib/utils');
+const { getPackageManager, getSelectionPrompt } = require('../lib/package-manager');
+
+async function main() {
+  const sessionsDir = getSessionsDir();
+  const learnedDir = getLearnedSkillsDir();
+
+  // Ensure directories exist
+  ensureDir(sessionsDir);
+  ensureDir(learnedDir);
+
+  // Check for recent session files (last 7 days)
+  const recentSessions = findFiles(sessionsDir, '*.tmp', { maxAge: 7 });
+
+  if (recentSessions.length > 0) {
+    const latest = recentSessions[0];
+    log(`[SessionStart] Found ${recentSessions.length} recent session(s)`);
+    log(`[SessionStart] Latest: ${latest.path}`);
+  }
+
+  // Check for learned skills
+  const learnedSkills = findFiles(learnedDir, '*.md');
+
+  if (learnedSkills.length > 0) {
+    log(`[SessionStart] ${learnedSkills.length} learned skill(s) available in ${learnedDir}`);
+  }
+
+  // Detect and report package manager
+  const pm = getPackageManager();
+  log(`[SessionStart] Package manager: ${pm.name} (${pm.source})`);
+
+  // If package manager was detected via fallback, show selection prompt
+  if (pm.source === 'fallback' || pm.source === 'default') {
+    log('[SessionStart] No package manager preference found.');
+    log(getSelectionPrompt());
+  }
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[SessionStart] Error:', err.message);
+  process.exit(0); // Don't block on errors
+});

package/scripts/hooks/suggest-compact.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+/**
+ * Strategic Compact Suggester
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs on PreToolUse or periodically to suggest manual compaction at logical intervals
+ *
+ * Why manual over auto-compact:
+ * - Auto-compact happens at arbitrary points, often mid-task
+ * - Strategic compacting preserves context through logical phases
+ * - Compact after exploration, before execution
+ * - Compact after completing a milestone, before starting next
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getTempDir,
+  readFile,
+  writeFile,
+  log
+} = require('../lib/utils');
+
+async function main() {
+  // Track tool call count (increment in a temp file)
+  // Use a session-specific counter file based on PID from parent process
+  // or session ID from environment
+  const sessionId = process.env.CLAUDE_SESSION_ID || process.ppid || 'default';
+  const counterFile = path.join(getTempDir(), `claude-tool-count-${sessionId}`);
+  const threshold = parseInt(process.env.COMPACT_THRESHOLD || '50', 10);
+
+  let count = 1;
+
+  // Read existing count or start at 1
+  const existing = readFile(counterFile);
+  if (existing) {
+    count = parseInt(existing.trim(), 10) + 1;
+  }
+
+  // Save updated count
+  writeFile(counterFile, String(count));
+
+  // Suggest compact after threshold tool calls
+  if (count === threshold) {
+    log(`[StrategicCompact] ${threshold} tool calls reached - consider /compact if transitioning phases`);
+  }
+
+  // Suggest at regular intervals after threshold
+  if (count > threshold && count % 25 === 0) {
+    log(`[StrategicCompact] ${count} tool calls - good checkpoint for /compact if context is stale`);
+  }
+
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('[StrategicCompact] Error:', err.message);
+  process.exit(0);
+});