gm-copilot-cli 2.0.5

package/hooks/hooks.json

@@ -0,0 +1,58 @@
+{
+  "description": "Hooks for gm GitHub Copilot CLI extension",
+  "hooks": {
+    "tool:invoke": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/pre-tool-use-hook.js",
+            "timeout": 3600
+          }
+        ]
+      }
+    ],
+    "session:start": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/session-start-hook.js",
+            "timeout": 10000
+          }
+        ]
+      }
+    ],
+    "prompt:submit": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/prompt-submit-hook.js",
+            "timeout": 3600
+          }
+        ]
+      }
+    ],
+    "session:end": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/session-end-hook.js",
+            "timeout": 300000
+          },
+          {
+            "type": "command",
+            "command": "node ${COPILOT_EXTENSION_DIR}/hooks/session-end-git-hook.js",
+            "timeout": 60000
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/pre-tool-use-hook.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const isGemini = process.env.GEMINI_PROJECT_DIR !== undefined;
+
+const shellTools = ['Bash', 'run_shell_command'];
+const writeTools = ['Write', 'write_file'];
+const searchTools = ['Glob', 'Grep', 'glob', 'search_file_content', 'Search', 'search'];
+const forbiddenTools = ['find', 'Find'];
+
+const run = () => {
+  try {
+    const input = fs.readFileSync(0, 'utf-8');
+    const data = JSON.parse(input);
+    const { tool_name, tool_input } = data;
+
+    if (!tool_name) return { allow: true };
+
+    if (forbiddenTools.includes(tool_name)) {
+      return { block: true, reason: 'Use gm:code-search or plugin:gm:dev for semantic codebase search instead of filesystem find' };
+    }
+
+    if (shellTools.includes(tool_name)) {
+      return { block: true, reason: 'Use dev execute instead for all command execution' };
+    }
+
+    if (writeTools.includes(tool_name)) {
+      const file_path = tool_input?.file_path || '';
+      const ext = path.extname(file_path);
+      const inSkillsDir = file_path.includes('/skills/');
+      const base = path.basename(file_path).toLowerCase();
+      if ((ext === '.md' || ext === '.txt' || base.startsWith('features_list')) &&
+          !base.startsWith('claude') && !base.startsWith('readme') && !inSkillsDir) {
+        return { block: true, reason: 'Cannot create documentation files. Only CLAUDE.md and readme.md are maintained.' };
+      }
+      if (/\.(test|spec)\.(js|ts|jsx|tsx|mjs|cjs)$/.test(base) ||
+          /^(jest|vitest|mocha|ava|jasmine|tap)\.(config|setup)/.test(base) ||
+          file_path.includes('/__tests__/') || file_path.includes('/test/') ||
+          file_path.includes('/tests/') || file_path.includes('/fixtures/') ||
+          file_path.includes('/test-data/') || file_path.includes('/__mocks__/') ||
+          /\.(snap|stub|mock|fixture)\.(js|ts|json)$/.test(base)) {
+        return { block: true, reason: 'Test files forbidden on disk. Use plugin:gm:dev with real services for all testing.' };
+      }
+    }
+
+    if (searchTools.includes(tool_name)) {
+      return { block: true, reason: 'Code exploration must use: gm:code-search skill or plugin:gm:dev execute. This restriction enforces semantic search over filesystem patterns.' };
+    }
+
+    if (tool_name === 'Task') {
+      const subagentType = tool_input?.subagent_type || '';
+      if (subagentType === 'Explore') {
+        return { block: true, reason: 'Use gm:thorns-overview for codebase insight, then use gm:code-search or plugin:gm:dev' };
+      }
+    }
+
+    if (tool_name === 'EnterPlanMode') {
+      return { block: true, reason: 'Plan mode is disabled. Use GM agent planning (PLAN→EXECUTE→EMIT→VERIFY→COMPLETE state machine) via gm:gm subagent instead.' };
+    }
+
+    return { allow: true };
+  } catch (error) {
+    return { allow: true };
+  }
+};
+
+try {
+  const result = run();
+
+  if (result.block) {
+    if (isGemini) {
+      console.log(JSON.stringify({ decision: 'deny', reason: result.reason }));
+    } else {
+      console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: result.reason } }));
+    }
+    process.exit(2);
+  }
+
+  if (isGemini) {
+    console.log(JSON.stringify({ decision: 'allow' }));
+  } else {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } }));
+  }
+  process.exit(0);
+} catch (error) {
+  if (isGemini) {
+    console.log(JSON.stringify({ decision: 'allow' }));
+  } else {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'allow' } }));
+  }
+  process.exit(0);
+}

package/hooks/prompt-submit-hook.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.env.GEMINI_PROJECT_DIR || process.env.OC_PROJECT_DIR;
+
+const COMPACT_CONTEXT = 'use gm agent | ref: TOOL_INVARIANTS | codesearch for exploration | plugin:gm:dev for execution';
+
+const PLAN_MODE_BLOCK = 'DO NOT use EnterPlanMode or any plan mode tool. Use GM agent planning (PLAN→EXECUTE→EMIT→VERIFY→COMPLETE state machine) instead. Plan mode is blocked.';
+
+const getBaseContext = (resetMsg = '') => {
+  let ctx = 'use gm agent';
+  if (resetMsg) ctx += ' - ' + resetMsg;
+  return ctx;
+};
+
+const readStdinPrompt = () => {
+  try {
+    const raw = fs.readFileSync(0, 'utf-8');
+    const data = JSON.parse(raw);
+    return data.prompt || '';
+  } catch (e) {
+    return '';
+  }
+};
+
+const runCodeSearch = (query, cwd) => {
+  if (!query || !cwd || !fs.existsSync(cwd)) return '';
+  try {
+    const escaped = query.replace(/"/g, '\\"').substring(0, 200);
+    let out;
+    try {
+      out = execSync(`bunx codebasesearch@latest "${escaped}"`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd,
+        timeout: 55000,
+        killSignal: 'SIGTERM'
+      });
+    } catch (bunErr) {
+      if (bunErr.killed) return '';
+      out = execSync(`npx -y codebasesearch@latest "${escaped}"`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd,
+        timeout: 55000,
+        killSignal: 'SIGTERM'
+      });
+    }
+    const lines = out.split('\n');
+    const resultStart = lines.findIndex(l => l.includes('Searching for:'));
+    return resultStart >= 0 ? lines.slice(resultStart).join('\n').trim() : out.trim();
+  } catch (e) {
+    return '';
+  }
+};
+
+const emit = (additionalContext) => {
+  const isGemini = process.env.GEMINI_PROJECT_DIR !== undefined;
+  const isOpenCode = process.env.OC_PLUGIN_ROOT !== undefined;
+
+  if (isGemini) {
+    console.log(JSON.stringify({ systemMessage: additionalContext }, null, 2));
+  } else if (isOpenCode) {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'message.updated', additionalContext } }, null, 2));
+  } else {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext } }, null, 2));
+  }
+};
+
+try {
+  const prompt = readStdinPrompt();
+  const parts = [getBaseContext() + ' | ' + COMPACT_CONTEXT + ' | ' + PLAN_MODE_BLOCK];
+
+  if (prompt && projectDir) {
+    const searchResults = runCodeSearch(prompt, projectDir);
+    if (searchResults) {
+      parts.push(`=== Semantic code search results for initial prompt ===\n${searchResults}`);
+    }
+  }
+
+  emit(parts.join('\n\n'));
+} catch (error) {
+  emit(getBaseContext('hook error: ' + error.message) + ' | ' + COMPACT_CONTEXT);
+  process.exit(0);
+}

package/hooks/session-end-git-hook.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+const getCounterPath = () => {
+  const hash = crypto.createHash('md5').update(projectDir).digest('hex');
+  return path.join('/tmp', `gm-git-block-counter-${hash}.json`);
+};
+
+const readCounter = () => {
+  try {
+    const counterPath = getCounterPath();
+    if (fs.existsSync(counterPath)) {
+      const data = fs.readFileSync(counterPath, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (e) {}
+  return { count: 0, lastGitHash: null };
+};
+
+const writeCounter = (data) => {
+  try {
+    const counterPath = getCounterPath();
+    fs.writeFileSync(counterPath, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (e) {}
+};
+
+const getCurrentGitHash = () => {
+  try {
+    const hash = execSync('git rev-parse HEAD', {
+      cwd: projectDir,
+      stdio: 'pipe',
+      encoding: 'utf-8'
+    }).trim();
+    return hash;
+  } catch (e) {
+    return null;
+  }
+};
+
+const resetCounterIfCommitted = (currentHash) => {
+  const counter = readCounter();
+  if (counter.lastGitHash && currentHash && counter.lastGitHash !== currentHash) {
+    counter.count = 0;
+    counter.lastGitHash = currentHash;
+    writeCounter(counter);
+    return true;
+  }
+  return false;
+};
+
+const incrementCounter = (currentHash) => {
+  const counter = readCounter();
+  counter.count = (counter.count || 0) + 1;
+  counter.lastGitHash = currentHash;
+  writeCounter(counter);
+  return counter.count;
+};
+
+const getGitStatus = () => {
+  try {
+    execSync('git rev-parse --git-dir', {
+      cwd: projectDir,
+      stdio: 'pipe'
+    });
+  } catch (e) {
+    return { isRepo: false };
+  }
+
+  try {
+    const status = execSync('git status --porcelain', {
+      cwd: projectDir,
+      stdio: 'pipe',
+      encoding: 'utf-8'
+    }).trim();
+
+    const isDirty = status.length > 0;
+
+    let unpushedCount = 0;
+    try {
+      const unpushed = execSync('git rev-list --count @{u}..HEAD', {
+        cwd: projectDir,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+      unpushedCount = parseInt(unpushed, 10) || 0;
+    } catch (e) {
+      unpushedCount = -1;
+    }
+
+    let behindCount = 0;
+    try {
+      const behind = execSync('git rev-list --count HEAD..@{u}', {
+        cwd: projectDir,
+        stdio: 'pipe',
+        encoding: 'utf-8'
+      }).trim();
+      behindCount = parseInt(behind, 10) || 0;
+    } catch (e) {}
+
+    return {
+      isRepo: true,
+      isDirty,
+      unpushedCount,
+      behindCount,
+      statusOutput: status
+    };
+  } catch (e) {
+    return { isRepo: true, isDirty: false, unpushedCount: 0, behindCount: 0 };
+  }
+};
+
+const run = () => {
+  const gitStatus = getGitStatus();
+  if (!gitStatus.isRepo) return { ok: true };
+
+  const currentHash = getCurrentGitHash();
+  resetCounterIfCommitted(currentHash);
+
+  const issues = [];
+  if (gitStatus.isDirty) {
+    issues.push('Uncommitted changes exist');
+  }
+  if (gitStatus.unpushedCount > 0) {
+    issues.push(`${gitStatus.unpushedCount} commit(s) not pushed`);
+  }
+  if (gitStatus.unpushedCount === -1) {
+    issues.push('Unable to verify push status - may have unpushed commits');
+  }
+  if (gitStatus.behindCount > 0) {
+    issues.push(`${gitStatus.behindCount} upstream change(s) not pulled`);
+  }
+
+  if (issues.length > 0) {
+    const blockCount = incrementCounter(currentHash);
+    return {
+      ok: false,
+      reason: `Git: ${issues.join(', ')}, must push to remote`,
+      blockCount
+    };
+  }
+
+  const counter = readCounter();
+  if (counter.count > 0) {
+    counter.count = 0;
+    writeCounter(counter);
+  }
+
+  return { ok: true };
+};
+
+try {
+  const result = run();
+  if (!result.ok) {
+    if (result.blockCount === 1) {
+      console.log(JSON.stringify({
+        decision: 'block',
+        reason: `Git: ${result.reason} [First violation - blocks this session]`
+      }, null, 2));
+      process.exit(2);
+    } else if (result.blockCount > 1) {
+      console.log(JSON.stringify({
+        decision: 'approve',
+        reason: `⚠️ Git warning (attempt #${result.blockCount}): ${result.reason} - Please commit and push your changes.`
+      }, null, 2));
+      process.exit(0);
+    }
+  } else {
+    console.log(JSON.stringify({
+      decision: 'approve'
+    }, null, 2));
+    process.exit(0);
+  }
+} catch (e) {
+  console.log(JSON.stringify({
+    decision: 'approve'
+  }, null, 2));
+  process.exit(0);
+}

package/hooks/session-end-hook.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+// Always use current working directory for .prd location
+// Explicitly resolve to ./.prd in the current folder
+const projectDir = process.cwd();
+const prdFile = path.resolve(projectDir, '.prd');
+
+let aborted = false;
+process.on('SIGTERM', () => { aborted = true; });
+process.on('SIGINT', () => { aborted = true; });
+
+const run = () => {
+  if (aborted) return { ok: true };
+
+  try {
+    // Check if .prd file exists and has content
+    if (fs.existsSync(prdFile)) {
+      const prdContent = fs.readFileSync(prdFile, 'utf-8').trim();
+      if (prdContent.length > 0) {
+        // .prd has content, block stopping
+        return {
+          ok: false,
+          reason: `Work items remain in ${prdFile}. Remove completed items as they finish. Current items:\n\n${prdContent}`
+        };
+      }
+    }
+
+    // .prd doesn't exist or is empty, allow stop
+    return { ok: true };
+  } catch (error) {
+    return { ok: true };
+  }
+};
+
+try {
+  const result = run();
+
+  if (!result.ok) {
+    console.log(JSON.stringify({
+      decision: 'block',
+      reason: result.reason
+    }, null, 2));
+    process.exit(2);
+  }
+
+  console.log(JSON.stringify({
+    decision: 'approve'
+  }, null, 2));
+  process.exit(0);
+} catch (e) {
+  console.log(JSON.stringify({
+    decision: 'approve'
+  }, null, 2));
+  process.exit(0);
+}

package/hooks/session-start-hook.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT || process.env.GEMINI_PROJECT_DIR || process.env.OC_PLUGIN_ROOT;
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.env.GEMINI_PROJECT_DIR || process.env.OC_PROJECT_DIR;
+
+const ensureGitignore = () => {
+  if (!projectDir) return;
+  const gitignorePath = path.join(projectDir, '.gitignore');
+  const entry = '.gm-stop-verified';
+  try {
+    let content = '';
+    if (fs.existsSync(gitignorePath)) {
+      content = fs.readFileSync(gitignorePath, 'utf-8');
+    }
+    if (!content.split('\n').some(line => line.trim() === entry)) {
+      const newContent = content.endsWith('\n') || content === ''
+        ? content + entry + '\n'
+        : content + '\n' + entry + '\n';
+      fs.writeFileSync(gitignorePath, newContent);
+    }
+  } catch (e) {
+    // Silently fail - not critical
+  }
+};
+
+ensureGitignore();
+
+try {
+  let outputs = [];
+
+  // 1. Read ./start.md
+  if (pluginRoot) {
+    const startMdPath = path.join(pluginRoot, '/agents/gm.md');
+    try {
+      const startMdContent = fs.readFileSync(startMdPath, 'utf-8');
+      outputs.push(startMdContent);
+    } catch (e) {
+      // File may not exist in this context
+    }
+  }
+
+  // 2. Add semantic code-search explanation
+  const codeSearchContext = `## 🔍 Semantic Code Search Now Available
+
+Your prompts will trigger **semantic code search** - intelligent, intent-based exploration of your codebase.
+
+### How It Works
+Describe what you need in plain language, and the search understands your intent:
+- "Find authentication validation" → locates auth checks, guards, permission logic
+- "Where is database initialization?" → finds connection setup, migrations, schemas
+- "Show error handling patterns" → discovers try/catch patterns, error boundaries
+
+NOT syntax-based regex matching - truly semantic understanding across files.
+
+### Example
+Instead of regex patterns, simply describe your intent:
+"Find where API authorization is checked"
+
+The search will find permission validations, role checks, authentication guards - however they're implemented.
+
+### When to Use Code Search
+When exploring unfamiliar code, finding similar patterns, understanding integrations, or locating feature implementations across your codebase.`;
+  outputs.push(codeSearchContext);
+
+  // 3. Run mcp-thorns (bunx with npx fallback)
+  if (projectDir && fs.existsSync(projectDir)) {
+    try {
+      let thornOutput;
+      try {
+        thornOutput = execSync(`bunx mcp-thorns@latest`, {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+          cwd: projectDir,
+          timeout: 180000,
+          killSignal: 'SIGTERM'
+        });
+      } catch (bunErr) {
+        if (bunErr.killed && bunErr.signal === 'SIGTERM') {
+          thornOutput = '=== mcp-thorns ===\nSkipped (3min timeout)';
+        } else {
+          try {
+            thornOutput = execSync(`npx -y mcp-thorns@latest`, {
+              encoding: 'utf-8',
+              stdio: ['pipe', 'pipe', 'pipe'],
+              cwd: projectDir,
+              timeout: 180000,
+              killSignal: 'SIGTERM'
+            });
+          } catch (npxErr) {
+            if (npxErr.killed && npxErr.signal === 'SIGTERM') {
+              thornOutput = '=== mcp-thorns ===\nSkipped (3min timeout)';
+            } else {
+              thornOutput = `=== mcp-thorns ===\nSkipped (error: ${bunErr.message.split('\n')[0]})`;
+            }
+          }
+        }
+      }
+      outputs.push(`=== This is your initial insight of the repository, look at every possible aspect of this for initial opinionation and to offset the need for code exploration ===\n${thornOutput}`);
+    } catch (e) {
+      if (e.killed && e.signal === 'SIGTERM') {
+        outputs.push(`=== mcp-thorns ===\nSkipped (3min timeout)`);
+      } else {
+        outputs.push(`=== mcp-thorns ===\nSkipped (error: ${e.message.split('\n')[0]})`);
+      }
+    }
+  }
+  outputs.push('Use gm as a philosophy to coordinate all plans and the gm subagent to create and execute all plans');
+  const additionalContext = outputs.join('\n\n');
+
+  const isGemini = process.env.GEMINI_PROJECT_DIR !== undefined;
+  const isOpenCode = process.env.OC_PLUGIN_ROOT !== undefined;
+
+  if (isGemini) {
+    const result = {
+      systemMessage: additionalContext
+    };
+    console.log(JSON.stringify(result, null, 2));
+  } else if (isOpenCode) {
+    const result = {
+      hookSpecificOutput: {
+        hookEventName: 'session.created',
+        additionalContext
+      }
+    };
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const result = {
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext
+      }
+    };
+    console.log(JSON.stringify(result, null, 2));
+  }
+} catch (error) {
+  const isGemini = process.env.GEMINI_PROJECT_DIR !== undefined;
+  const isOpenCode = process.env.OC_PLUGIN_ROOT !== undefined;
+
+  if (isGemini) {
+    console.log(JSON.stringify({
+      systemMessage: `Error executing hook: ${error.message}`
+    }, null, 2));
+  } else if (isOpenCode) {
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'session.created',
+        additionalContext: `Error executing hook: ${error.message}`
+      }
+    }, null, 2));
+  } else {
+    console.log(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'SessionStart',
+        additionalContext: `Error executing hook: ${error.message}`
+      }
+    }, null, 2));
+  }
+  process.exit(0);
+}
+
+
+
+
+
+
+
+

package/manifest.yml

@@ -0,0 +1,51 @@
+name: gm
+version: 2.0.5
+description: Advanced Claude Code plugin with WFGY integration, MCP tools, and automated hooks
+author: AnEntrypoint
+
+repository:
+  url: https://github.com/AnEntrypoint/gm-copilot-cli
+  type: git
+
+license: MIT
+
+keywords:
+  - ai
+  - state-machine
+  - agent
+
+activation:
+  on_load: true
+  auto_activate: true
+
+commands:
+  - name: gm:activate
+    description: Activate state machine
+  - name: gm:analyze
+    description: Analyze code
+  - name: gm:search
+    description: Semantic search
+  - name: gm:refactor
+    description: Refactor code
+
+api:
+  version: 1.0.0
+  min_gh_version: 2.45.0
+
+permissions:
+  - read:environment
+  - read:project
+  - write:project
+
+configuration:
+  settings:
+    - name: enabled
+      type: boolean
+      default: true
+    - name: auto_activate
+      type: boolean
+      default: true
+    - name: log_level
+      type: string
+      enum: [debug, info, warn, error]
+      default: info