gm-cc 2.0.5

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/hooks/stop-hook-git.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/stop-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/install.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+
+function isInsideNodeModules() {
+  return __dirname.includes(path.sep + 'node_modules' + path.sep);
+}
+
+function getProjectRoot() {
+  if (!isInsideNodeModules()) {
+    return null;
+  }
+
+  let current = __dirname;
+  while (current !== path.dirname(current)) {
+    current = path.dirname(current);
+    const parent = path.dirname(current);
+    if (path.basename(current) === 'node_modules') {
+      return parent;
+    }
+  }
+  return null;
+}
+
+function safeCopyFile(src, dst) {
+  try {
+    const content = fs.readFileSync(src, 'utf-8');
+    const dstDir = path.dirname(dst);
+    if (!fs.existsSync(dstDir)) {
+      fs.mkdirSync(dstDir, { recursive: true });
+    }
+    fs.writeFileSync(dst, content, 'utf-8');
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function safeCopyDirectory(src, dst) {
+  try {
+    if (!fs.existsSync(src)) {
+      return false;
+    }
+
+    fs.mkdirSync(dst, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+
+    entries.forEach(entry => {
+      const srcPath = path.join(src, entry.name);
+      const dstPath = path.join(dst, entry.name);
+
+      if (entry.isDirectory()) {
+        safeCopyDirectory(srcPath, dstPath);
+      } else if (entry.isFile()) {
+        safeCopyFile(srcPath, dstPath);
+      }
+    });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function updateGitignore(projectRoot) {
+  try {
+    const gitignorePath = path.join(projectRoot, '.gitignore');
+    const entry = '.gm-stop-verified';
+
+    let content = '';
+    if (fs.existsSync(gitignorePath)) {
+      content = fs.readFileSync(gitignorePath, 'utf-8');
+    }
+
+    if (content.includes(entry)) {
+      return true;
+    }
+
+    if (content && !content.endsWith('\n')) {
+      content += '\n';
+    }
+    content += entry + '\n';
+
+    fs.writeFileSync(gitignorePath, content, 'utf-8');
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function install() {
+  if (!isInsideNodeModules()) {
+    return;
+  }
+
+  const projectRoot = getProjectRoot();
+  if (!projectRoot) {
+    return;
+  }
+
+  const claudeDir = path.join(projectRoot, '.claude');
+  const sourceDir = __dirname.replace(/[\/]scripts$/, '');
+
+  safeCopyDirectory(path.join(sourceDir, 'agents'), path.join(claudeDir, 'agents'));
+  safeCopyDirectory(path.join(sourceDir, 'hooks'), path.join(claudeDir, 'hooks'));
+  safeCopyFile(path.join(sourceDir, '.mcp.json'), path.join(claudeDir, '.mcp.json'));
+
+  updateGitignore(projectRoot);
+}
+
+install();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "gm-cc",
+  "version": "2.0.5",
+  "description": "Advanced Claude Code plugin with WFGY integration, MCP tools, and automated hooks",
+  "author": "AnEntrypoint",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnEntrypoint/gm-cc.git"
+  },
+  "homepage": "https://github.com/AnEntrypoint/gm-cc#readme",
+  "bugs": {
+    "url": "https://github.com/AnEntrypoint/gm-cc/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "gm-cc": "./cli.js",
+    "gm-install": "./install.js"
+  },
+  "files": [
+    "agents/",
+    "hooks/",
+    "scripts/",
+    "skills/",
+    ".github/",
+    ".mcp.json",
+    ".claude-plugin/",
+    "plugin.json",
+    "cli.js",
+    "install.js",
+    "README.md",
+    "LICENSE",
+    ".gitignore",
+    ".editorconfig",
+    "CONTRIBUTING.md",
+    "CLAUDE.md"
+  ],
+  "keywords": [
+    "claude-code",
+    "agent",
+    "state-machine",
+    "mcp",
+    "automation",
+    "gm"
+  ],
+  "peerDependencies": {
+    "@anthropic-ai/claude-code": "*"
+  }
+}

package/plugin.json

@@ -0,0 +1,27 @@
+{
+  "name": "gm",
+  "version": "2.0.5",
+  "description": "Advanced Claude Code plugin with WFGY integration, MCP tools, and automated hooks",
+  "author": {
+    "name": "AnEntrypoint",
+    "url": "https://github.com/AnEntrypoint"
+  },
+  "homepage": "https://github.com/AnEntrypoint/gm",
+  "hooks": "./hooks/hooks.json",
+  "mcpServers": {
+    "dev": {
+      "command": "bunx",
+      "args": [
+        "mcp-gm@latest"
+      ],
+      "timeout": 360000
+    },
+    "code-search": {
+      "command": "bunx",
+      "args": [
+        "codebasesearch@latest"
+      ],
+      "timeout": 360000
+    }
+  }
+}