ecc_infisense 0.0.1

package/commands/infi-release.md

@@ -0,0 +1,83 @@
+---
+description: Git commit and npm publish with version management.
+category: plugin
+---
+
+# Release Management
+
+Manage ECC InfiSense releases through three workflows: git update, npm publish,
+and status. Delegates execution to the `release-executor` agent.
+
+## Usage
+
+`/infi-release [git-update|publish|status] [options]`
+
+If mode is omitted, present an interactive menu using AskUserQuestion:
+
+```
+Which release workflow do you want to run?
+
+1. git update
+   Detect changes, commit with conventional commits, update CHANGELOG.md
+2. npm publish
+   Bump version, update CHANGELOG.md, tag, push, npm publish
+3. status
+   Show current version, last tag, and unreleased changes
+```
+
+---
+
+## 1. git update
+
+Detect uncommitted changes, make all necessary file modifications, then commit.
+
+Delegate to `release-executor` agent which will:
+
+1. **Detect changes** — scan git status for modified, added, deleted files
+2. **Analyze and group** — map file paths to commit types/scopes using
+   `release-workflow` skill conventions
+3. **Safety checks** — scan for dangerous files, debug code, validate message format
+4. **Update CHANGELOG.md** — categorize changes per Keep a Changelog format
+5. **Update documentation** — sync component counts in README.md, GUIDE.md, CLAUDE.md
+6. **Commit** — stage and commit (single or multiple atomic commits)
+
+Show all findings and grouping plan to user. Wait for confirmation before committing.
+
+---
+
+## 2. npm publish
+
+Full release: bump version, finalize changelog, tag, push, publish.
+
+Delegate to `release-executor` agent which will:
+
+1. **Ensure clean tree** — run git update first if uncommitted changes exist
+2. **Pre-flight** — run `npm test`, abort if tests fail
+3. **Bump version** — ask user for level (patch/minor/major), update package.json
+   and plugin.json
+4. **Finalize changelog** — move `[Unreleased]` to versioned section
+5. **Update documentation** — sync version and counts in README.md, GUIDE.md
+6. **Commit, tag, push, publish** — single release commit with version tag
+
+---
+
+## 3. status
+
+Read-only — show current state without making changes.
+
+Delegate to `release-executor` agent to display:
+
+- Current version from package.json
+- Last git tag
+- Commit count since last tag
+- Uncommitted changes summary
+- Unreleased changelog entries
+
+---
+
+## Cross-References
+
+- Agent: `release-executor` — executes all three release workflows
+- Skill: `release-workflow` — commit conventions, path-scope mapping, changelog format
+- Related: `/infi-component-creator` — create components before releasing
+- Related: `/infi-ecc-helper` — view current plugin overview

package/hooks/hooks.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/suggest-compact.js\""
+          }
+        ],
+        "description": "Suggest manual compaction at logical intervals"
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/pre-compact.js\""
+          }
+        ],
+        "description": "Save state before context compaction"
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/session-start.js\""
+          }
+        ],
+        "description": "Load previous context and detect build system on new session"
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hooks/session-end.js\""
+          }
+        ],
+        "description": "Persist session state on end"
+      }
+    ]
+  }
+}

package/install.sh

@@ -0,0 +1,237 @@
+#!/usr/bin/env bash
+# install.sh — Install ECC InfiSense plugin for Claude Code.
+#
+# Usage:
+#   ./install.sh
+#
+# This script copies all plugin components into ~/.claude/:
+#   - rules/    → ~/.claude/rules/common/
+#   - commands/ → ~/.claude/commands/
+#   - agents/   → ~/.claude/agents/
+#   - skills/   → ~/.claude/skills/
+#   - hooks     → ~/.claude/settings.json (merged)
+#
+# Update safety:
+#   A manifest file (~/.claude/.ecc-infisense-manifest) tracks every file
+#   installed by this plugin. On re-install, files listed in the old manifest
+#   but absent from the new version are automatically removed, without
+#   touching files owned by the user or other plugins.
+
+set -euo pipefail
+
+# Resolve symlinks — needed when invoked as `ecc-infisense-install` via npm/bun bin symlink
+SCRIPT_PATH="$0"
+while [ -L "$SCRIPT_PATH" ]; do
+    link_dir="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+    SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
+    # Resolve relative symlinks
+    [[ "$SCRIPT_PATH" != /* ]] && SCRIPT_PATH="$link_dir/$SCRIPT_PATH"
+done
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+RULES_DIR="$SCRIPT_DIR/rules"
+
+# --- Manifest helpers ---
+# The manifest tracks every file installed by this plugin so that upgrades
+# can remove files that no longer exist in the new version, without touching
+# files owned by the user or other plugins.
+
+MANIFEST_FILE="$HOME/.claude/.ecc-infisense-manifest"
+NEW_MANIFEST=()
+
+# Record a file path into the new manifest (call after each cp)
+record() {
+    NEW_MANIFEST+=("$1")
+}
+
+# Record all files under a directory tree
+record_tree() {
+    local dir="$1"
+    while IFS= read -r -d '' f; do
+        record "$f"
+    done < <(find "$dir" -type f -print0 2>/dev/null)
+}
+
+# Remove files from old manifest that are not in the new manifest
+cleanup_old_manifest() {
+    if [[ ! -f "$MANIFEST_FILE" ]]; then
+        return
+    fi
+
+    local removed=0
+    while IFS= read -r old_file; do
+        [[ -z "$old_file" ]] && continue
+        # Check if this file is still in the new manifest
+        local found=false
+        for new_file in "${NEW_MANIFEST[@]}"; do
+            if [[ "$new_file" == "$old_file" ]]; then
+                found=true
+                break
+            fi
+        done
+        if ! $found && [[ -f "$old_file" ]]; then
+            rm -f "$old_file"
+            removed=$((removed + 1))
+        fi
+    done < "$MANIFEST_FILE"
+
+    if [[ $removed -gt 0 ]]; then
+        echo "Cleaned up $removed file(s) from previous installation."
+    fi
+
+    # Remove empty directories left behind (only under ~/.claude/)
+    find "$HOME/.claude/rules" "$HOME/.claude/commands" "$HOME/.claude/agents" "$HOME/.claude/skills" \
+        -type d -empty -delete 2>/dev/null || true
+}
+
+# Write the new manifest to disk
+save_manifest() {
+    mkdir -p "$(dirname "$MANIFEST_FILE")"
+    printf '%s\n' "${NEW_MANIFEST[@]}" > "$MANIFEST_FILE"
+}
+
+# --- Install ---
+
+install_plugin() {
+    local DEST_DIR="${CLAUDE_RULES_DIR:-$HOME/.claude/rules}"
+    local CMD_DIR="$HOME/.claude/commands"
+    local AGENTS_DIR="$HOME/.claude/agents"
+    local SKILLS_DIR="$HOME/.claude/skills"
+    local COMMANDS_SRC="$SCRIPT_DIR/commands"
+    local AGENTS_SRC="$SCRIPT_DIR/agents"
+    local SKILLS_SRC="$SCRIPT_DIR/skills"
+    local SETTINGS_FILE="$HOME/.claude/settings.json"
+    local HOOKS_SRC="$SCRIPT_DIR/hooks/hooks.json"
+
+    # --- Rules ---
+
+    # Install common rules
+    if [[ -d "$RULES_DIR/common" ]]; then
+        echo "Installing rules -> $DEST_DIR/common/"
+        rm -rf "$DEST_DIR/common"
+        mkdir -p "$DEST_DIR/common"
+        cp -r "$RULES_DIR/common/." "$DEST_DIR/common/"
+        record_tree "$DEST_DIR/common"
+    fi
+
+    # Install language-specific rules if they exist
+    for lang_dir in "$RULES_DIR"/*/; do
+        [[ -d "$lang_dir" ]] || continue
+        local lang
+        lang="$(basename "$lang_dir")"
+        [[ "$lang" == "common" ]] && continue
+
+        echo "Installing $lang rules -> $DEST_DIR/$lang/"
+        rm -rf "$DEST_DIR/$lang"
+        mkdir -p "$DEST_DIR/$lang"
+        cp -r "$lang_dir." "$DEST_DIR/$lang/"
+        record_tree "$DEST_DIR/$lang"
+    done
+
+    echo "Rules installed to $DEST_DIR/"
+
+    # --- Commands ---
+    if [[ -d "$COMMANDS_SRC" ]]; then
+        echo "Installing commands -> $CMD_DIR/"
+        mkdir -p "$CMD_DIR"
+        for f in "$COMMANDS_SRC"/*.md; do
+            [[ -f "$f" ]] || continue
+            local dest="$CMD_DIR/$(basename "$f")"
+            cp "$f" "$dest"
+            record "$dest"
+        done
+        echo "Commands installed ($(ls "$COMMANDS_SRC"/*.md 2>/dev/null | wc -l) files)"
+    fi
+
+    # --- Agents ---
+    if [[ -d "$AGENTS_SRC" ]]; then
+        echo "Installing agents -> $AGENTS_DIR/"
+        mkdir -p "$AGENTS_DIR"
+        for f in "$AGENTS_SRC"/*; do
+            [[ -f "$f" ]] || continue
+            local dest="$AGENTS_DIR/$(basename "$f")"
+            cp "$f" "$dest"
+            record "$dest"
+        done
+        echo "Agents installed ($(ls "$AGENTS_SRC"/ 2>/dev/null | wc -l) files)"
+    fi
+
+    # --- Skills ---
+    if [[ -d "$SKILLS_SRC" ]]; then
+        echo "Installing skills -> $SKILLS_DIR/"
+        mkdir -p "$SKILLS_DIR"
+        for skill_dir in "$SKILLS_SRC"/*/; do
+            [[ -d "$skill_dir" ]] || continue
+            local skill_name
+            skill_name="$(basename "$skill_dir")"
+            local dest_skill="$SKILLS_DIR/$skill_name"
+            rm -rf "$dest_skill"
+            mkdir -p "$dest_skill"
+            cp -r "$skill_dir." "$dest_skill/"
+            record_tree "$dest_skill"
+        done
+        echo "Skills installed ($(find "$SKILLS_SRC" -maxdepth 1 -mindepth 1 -type d | wc -l) skills)"
+    fi
+
+    # --- Cleanup old files and save new manifest ---
+    cleanup_old_manifest
+    save_manifest
+
+    # --- Merge hooks into ~/.claude/settings.json ---
+    if [[ -f "$HOOKS_SRC" ]] && command -v node >/dev/null 2>&1; then
+        echo "Installing hooks into $SETTINGS_FILE ..."
+        node -e "
+const fs = require('fs');
+const hooksPath = '$HOOKS_SRC';
+const settingsPath = '$SETTINGS_FILE';
+const pluginRoot = '$SCRIPT_DIR';
+
+// Read new hooks
+const newHooks = JSON.parse(fs.readFileSync(hooksPath, 'utf8'));
+
+// Read existing settings or create empty
+let settings = {};
+try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+} catch {}
+
+// Replace \${CLAUDE_PLUGIN_ROOT} with actual path in hook commands
+const hooksStr = JSON.stringify(newHooks.hooks || newHooks)
+    .replace(/\\$\\{CLAUDE_PLUGIN_ROOT\\}/g, pluginRoot);
+const resolvedHooks = JSON.parse(hooksStr);
+
+// Merge hooks (overwrite event types from plugin)
+if (!settings.hooks) settings.hooks = {};
+for (const [event, matchers] of Object.entries(resolvedHooks)) {
+    settings.hooks[event] = matchers;
+}
+
+// Remove event types that are no longer in the plugin
+const pluginEvents = Object.keys(resolvedHooks);
+for (const event of Object.keys(settings.hooks)) {
+    if (!pluginEvents.includes(event)) {
+        // Check if all matchers in this event reference our plugin
+        const matchers = settings.hooks[event];
+        const allOurs = matchers.every(m =>
+            m.hooks && m.hooks.every(h =>
+                h.command && h.command.includes(pluginRoot)
+            )
+        );
+        if (allOurs) {
+            delete settings.hooks[event];
+        }
+    }
+}
+
+fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+console.log('Hooks merged into ' + settingsPath);
+"
+    else
+        echo "Warning: node not found or hooks.json missing. Hooks not installed." >&2
+        echo "         Install Node.js 18+ and re-run to enable hooks." >&2
+    fi
+}
+
+install_plugin
+
+echo ""
+echo "Done. Run '/infi-ecc-helper' in Claude Code to verify."

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "ecc_infisense",
+  "version": "0.0.1",
+  "description": "Claude Code plugin for C/C++ development — agents, skills, hooks, commands, and rules for component management, release workflow, and C++ coding conventions",
+  "keywords": [
+    "claude-code",
+    "cpp",
+    "c++",
+    "plugin",
+    "agents",
+    "skills",
+    "hooks",
+    "rules"
+  ],
+  "author": "ECC InfiSense Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@172.16.40.222:sunchaoyue/ecc-infisense.git"
+  },
+  "homepage": "http://172.16.40.222/sunchaoyue/ecc-infisense",
+  "bugs": {
+    "url": "http://172.16.40.222/sunchaoyue/ecc-infisense/issues"
+  },
+  "files": [
+    "agents/",
+    "commands/",
+    "hooks/",
+    "rules/",
+    "scripts/hooks/",
+    "scripts/lib/",
+    "skills/",
+    ".claude-plugin/plugin.json",
+    "install.sh"
+  ],
+  "bin": {
+    "ecc_infisense-install": "install.sh"
+  },
+  "scripts": {
+    "postinstall": "echo '\\n  ecc_infisense installed!\\n  Run: ./install.sh\\n  Docs: http://172.16.40.222/sunchaoyue/ecc-infisense\\n'",
+    "lint": "markdownlint '**/*.md' --ignore node_modules",
+    "test": "node scripts/ci/validate-agents.js && node scripts/ci/validate-commands.js && node scripts/ci/validate-rules.js && node scripts/ci/validate-skills.js && node scripts/ci/validate-hooks.js && node scripts/ci/validate-version-sync.js && node scripts/ci/validate-cross-references.js && node tests/run-all.js"
+  },
+  "devDependencies": {
+    "markdownlint-cli": "^0.47.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/rules/common/agents.md

@@ -0,0 +1,28 @@
+# Agent Usage Guide
+
+## When to Delegate
+
+Use agents for: multi-file operations, component design, plugin analysis, release management.
+Do NOT delegate: single-file edits, simple tasks where you have full context.
+
+## Agent Selection
+
+| Agent | Use For |
+|-------|---------|
+| `@component-designer` | Design new components, analyze existing ones, rename for clarity |
+| `@plugin-inspector` | Scan directories, generate categorized component index |
+| `@release-executor` | Git commit workflows, npm publish, version status |
+
+## Coordination Patterns
+
+- Sequential: design components → create → release
+- `/infi-component-creator` delegates to `component-designer`
+- `/infi-ecc-helper` delegates to `plugin-inspector`
+- `/infi-release` delegates to `release-executor`
+
+## Best Practices
+
+1. Always include file paths, error messages, or design constraints
+2. Be specific: "Analyze agents/ for orphan components" not "analyze project"
+3. Share results between agents in multi-agent workflows
+4. Agent output is a starting point; refine with follow-ups

package/rules/common/development-workflow.md

@@ -0,0 +1,26 @@
+# Development Workflow
+
+## Core Cycle
+
+```
+Edit → Compile-Check → Test → Commit (iterate)
+```
+
+## Steps
+
+1. Plan before implementing any non-trivial change
+2. After every code edit, verify it compiles
+3. Review your own code before committing
+4. Use `/infi-release git-update` to commit with conventional commits
+
+## Always Compile-Check After Edits
+
+- After every code edit, verify it compiles
+- Do not accumulate multiple edits without checking
+- Quick check: `g++ -std=c++20 -fsyntax-only -Wall -Wextra file.cpp`
+
+## Workflow Rules
+
+- Never commit without tests
+- Never push without verification
+- Keep commits atomic (one logical change)

package/rules/common/git-workflow.md

@@ -0,0 +1,45 @@
+# Git Workflow Conventions
+
+## Conventional Commits
+
+Format: `<type>(<scope>): <subject>`
+
+| Type | Use |
+|------|-----|
+| `feat` | New feature |
+| `fix` | Bug fix |
+| `docs` | Documentation |
+| `refactor` | No behavior change |
+| `test` | Tests |
+| `chore` | Build, CI, tooling |
+| `perf` | Performance |
+
+Subject rules: lowercase, no period, imperative mood, max 72 chars.
+Body explains **why**, not what. Breaking changes: `!` after type + `BREAKING CHANGE:` footer.
+
+## Atomic Commits
+
+One logical change per commit. If you can say "X and Y", make two commits.
+
+## Branch Naming
+
+```
+feature/<issue-id>-<short-description>
+bugfix/<issue-id>-<short-description>
+hotfix/<issue-id>-<short-description>
+release/<version>
+```
+
+## Pre-Push Checklist
+
+- [ ] Compiles without warnings (`-Wall -Wextra -Werror`)
+- [ ] All tests pass
+- [ ] New code has test coverage
+- [ ] clang-format applied
+- [ ] No debug prints or commented-out code
+
+## Protected Branches
+
+- `main`: never force push, all changes via PR, requires CI + review
+- `develop`: never force push, feature branches merge here
+- Feature branches: force push OK, rebase on develop, delete after merge

package/rules/common/hooks.md

@@ -0,0 +1,36 @@
+# Hook Development Guidelines
+
+## Protocol
+
+- Input: JSON from stdin (event, files, context)
+- Output: JSON to stdout with `status`: `"pass"`, `"warn"`, or `"block"`
+- Human messages via stderr (`log()` function)
+- Exit codes: 0 = pass, 1 = hook error, 2 = intentional block
+
+## Performance
+
+| Hook Type | Max Duration |
+|-----------|-------------|
+| Synchronous (post-edit) | 5 seconds |
+| Asynchronous (post-build) | 30 seconds |
+| Pre-commit | 10 seconds |
+
+Only check changed files, not the entire project. Cache results between invocations.
+
+## Error Handling
+
+A hook's internal failure must never block the developer. On crash: exit 0, log error.
+Only exit 2 for intentional policy violations.
+
+## Testing
+
+Test hooks with mock JSON input before deploying:
+```bash
+cat mock-input.json | python3 hooks/my-hook.py
+```
+
+## File Patterns
+
+Source: `*.cpp`, `*.c`, `*.cxx`, `*.cc`
+Headers: `*.h`, `*.hpp`, `*.hxx`
+Templates: `*.inl`, `*.tpp`

package/scripts/hooks/pre-compact.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * PreCompact hook — Save state before context compaction.
+ *
+ * When Claude Code compacts the context window, important state can be lost.
+ * This hook persists the current session state (build config, recent test
+ * results, and pending tasks) so it can be restored after compaction.
+ */
+
+const path = require('path');
+const {
+  readStdinJson, log, output,
+  getSessionsDir, ensureDir, getSessionIdShort,
+  getDateTimeString, getProjectName, runCommand, readFile, writeFile,
+} = require('../lib/utils');
+
+function detectBuildConfig() {
+  const config = {};
+  const cmake = runCommand('cmake --version');
+  if (cmake.success) {
+    const match = cmake.output.match(/cmake version ([\d.]+)/);
+    config.cmakeVersion = match ? match[1] : 'unknown';
+  }
+  const buildDirs = ['build', 'cmake-build-debug', 'cmake-build-release', '_build'];
+  const fs = require('fs');
+  for (const d of buildDirs) {
+    if (fs.existsSync(d) && fs.statSync(d).isDirectory()) {
+      config.buildDir = d;
+      break;
+    }
+  }
+  return config;
+}
+
+async function main() {
+  const data = await readStdinJson();
+
+  const sessionsDir = ensureDir(getSessionsDir());
+  const sessionId = getSessionIdShort('default');
+  const stateFile = path.join(sessionsDir, `pre-compact-${sessionId}.json`);
+
+  const existingState = (() => {
+    const raw = readFile(stateFile);
+    if (!raw) return {};
+    try { return JSON.parse(raw); } catch { return {}; }
+  })();
+
+  const state = {
+    ...existingState,
+    timestamp: getDateTimeString(),
+    project: getProjectName(),
+    cwd: process.cwd(),
+    buildConfig: detectBuildConfig(),
+    compactionCount: (existingState.compactionCount || 0) + 1,
+    env: {
+      cc: process.env.CC || null,
+      cxx: process.env.CXX || null,
+      cmakeGenerator: process.env.CMAKE_GENERATOR || null,
+    },
+  };
+
+  writeFile(stateFile, JSON.stringify(state, null, 2));
+
+  log(`[infisense:pre-compact] Session state saved (compaction #${state.compactionCount}).`);
+  log(`[infisense:pre-compact] Build dir: ${state.buildConfig.buildDir || 'not detected'}`);
+  log(`[infisense:pre-compact] Project: ${state.project || 'unknown'}`);
+
+  output(data);
+}
+
+main().catch(() => process.exit(0));