ecc_infisense 0.0.1

package/scripts/hooks/session-end.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/**
+ * SessionEnd hook — Persist session state on end.
+ *
+ * Saves the current session state (build system, working directory, timestamp,
+ * environment details) so the next session can pick up where this one left off.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  readStdinJson, log, output,
+  getSessionsDir, ensureDir, getSessionIdShort,
+  getDateTimeString, getProjectName, readFile, writeFile,
+} = require('../lib/utils');
+
+function detectBuildDir() {
+  const candidates = ['build', 'cmake-build-debug', 'cmake-build-release', '_build', 'out/build'];
+  for (const c of candidates) {
+    if (fs.existsSync(c) && fs.statSync(c).isDirectory()) return c;
+  }
+  return null;
+}
+
+function detectBuildSystems() {
+  const systems = [];
+  if (fs.existsSync('CMakeLists.txt'))     systems.push('CMake');
+  if (fs.existsSync('Makefile'))           systems.push('Make');
+  if (fs.existsSync('build.ninja'))        systems.push('Ninja');
+  if (fs.existsSync('BUILD') || fs.existsSync('WORKSPACE')) systems.push('Bazel');
+  if (fs.existsSync('meson.build'))        systems.push('Meson');
+  return systems;
+}
+
+async function main() {
+  const data = await readStdinJson();
+
+  const sessionsDir = ensureDir(getSessionsDir());
+  const sessionId = getSessionIdShort('default');
+  const stateFile = path.join(sessionsDir, `session-${sessionId}.json`);
+
+  // Load existing state
+  let existingState = {};
+  const raw = readFile(stateFile);
+  if (raw) {
+    try { existingState = JSON.parse(raw); } catch { /* ignore */ }
+  }
+
+  const state = {
+    ...existingState,
+    sessionEnded: getDateTimeString(),
+    project: getProjectName(),
+    cwd: process.cwd(),
+    buildSystems: detectBuildSystems(),
+    buildDir: detectBuildDir(),
+    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:session-end] Session state saved for project: ${state.project || 'unknown'}`);
+  log(`[infisense:session-end] State file: ${stateFile}`);
+
+  output(data);
+}
+
+main().catch(() => process.exit(0));

package/scripts/hooks/session-start.js

@@ -0,0 +1,124 @@
+'use strict';
+
+/**
+ * SessionStart hook — Load previous context and detect build system.
+ *
+ * On a new session, this hook:
+ *   1. Loads any saved session state from previous sessions.
+ *   2. Detects the build system (CMake, Make, Ninja, Bazel, Meson).
+ *   3. Detects package managers (Conan, vcpkg).
+ *   4. Logs a configuration summary to stderr.
+ *   5. Outputs a context summary so Claude has immediate project awareness.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  readStdinJson, log, output,
+  getSessionsDir, getSessionIdShort,
+  getDateTimeString, getProjectName,
+  commandExists, runCommand, readFile, writeFile, ensureDir,
+} = require('../lib/utils');
+
+function detectBuildSystem() {
+  const systems = [];
+  if (fs.existsSync('CMakeLists.txt'))     systems.push('CMake');
+  if (fs.existsSync('Makefile'))           systems.push('Make');
+  if (fs.existsSync('build.ninja'))        systems.push('Ninja');
+  if (fs.existsSync('BUILD') || fs.existsSync('WORKSPACE')) systems.push('Bazel');
+  if (fs.existsSync('meson.build'))        systems.push('Meson');
+  if (fs.existsSync('premake5.lua'))       systems.push('Premake');
+  return systems;
+}
+
+function detectPackageManagers() {
+  const managers = [];
+  if (fs.existsSync('conanfile.txt') || fs.existsSync('conanfile.py')) managers.push('Conan');
+  if (fs.existsSync('vcpkg.json'))         managers.push('vcpkg');
+  if (fs.existsSync('hunter-gate.cmake'))  managers.push('Hunter');
+  if (fs.existsSync('CPM.cmake'))          managers.push('CPM');
+  return managers;
+}
+
+function detectToolchain() {
+  const tools = {};
+  if (commandExists('gcc'))        tools.gcc = true;
+  if (commandExists('g++'))        tools.gpp = true;
+  if (commandExists('clang'))      tools.clang = true;
+  if (commandExists('clang++'))    tools.clangpp = true;
+  if (commandExists('clang-tidy')) tools.clangTidy = true;
+  if (commandExists('clang-format')) tools.clangFormat = true;
+  if (commandExists('valgrind'))   tools.valgrind = true;
+  if (commandExists('cppcheck'))   tools.cppcheck = true;
+  if (commandExists('cmake'))      tools.cmake = true;
+  if (commandExists('ninja'))      tools.ninja = true;
+  return tools;
+}
+
+function findBuildDir() {
+  const candidates = ['build', 'cmake-build-debug', 'cmake-build-release', '_build', 'out/build'];
+  for (const c of candidates) {
+    if (fs.existsSync(c) && fs.statSync(c).isDirectory()) return c;
+  }
+  return null;
+}
+
+async function main() {
+  const data = await readStdinJson();
+
+  // Load previous session state
+  const sessionsDir = ensureDir(getSessionsDir());
+  const sessionId = getSessionIdShort('default');
+  const stateFile = path.join(sessionsDir, `session-${sessionId}.json`);
+  let prevState = {};
+  const raw = readFile(stateFile);
+  if (raw) {
+    try { prevState = JSON.parse(raw); } catch { /* ignore */ }
+  }
+
+  // Detect current environment
+  const buildSystems = detectBuildSystem();
+  const packageManagers = detectPackageManagers();
+  const toolchain = detectToolchain();
+  const buildDir = findBuildDir();
+  const project = getProjectName();
+
+  // Save new session state
+  const state = {
+    ...prevState,
+    sessionStarted: getDateTimeString(),
+    project,
+    cwd: process.cwd(),
+    buildSystems,
+    packageManagers,
+    buildDir,
+    toolchain: Object.keys(toolchain),
+    resumeCount: (prevState.resumeCount || 0) + 1,
+  };
+  writeFile(stateFile, JSON.stringify(state, null, 2));
+
+  // Log summary
+  log('[infisense:session-start] ---- C/C++ Project Detected ----');
+  log(`[infisense:session-start] Project: ${project || 'unknown'}`);
+  log(`[infisense:session-start] Build system(s): ${buildSystems.join(', ') || 'none detected'}`);
+  log(`[infisense:session-start] Package manager(s): ${packageManagers.join(', ') || 'none detected'}`);
+  log(`[infisense:session-start] Build directory: ${buildDir || 'not found'}`);
+  log(`[infisense:session-start] Available tools: ${Object.keys(toolchain).join(', ') || 'none'}`);
+  if (prevState.sessionStarted) {
+    log(`[infisense:session-start] Previous session: ${prevState.sessionStarted} (resume #${state.resumeCount})`);
+  }
+  log('[infisense:session-start] ---- End Detection ----');
+
+  // Output context summary for Claude
+  const summary = {
+    project,
+    buildSystems,
+    packageManagers,
+    buildDir,
+    toolchain: Object.keys(toolchain),
+    previousSession: prevState.sessionStarted || null,
+  };
+  output(summary);
+}
+
+main().catch(() => process.exit(0));

package/scripts/hooks/suggest-compact.js

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * PreToolUse hook (Edit|Write) — Suggest manual compaction at logical intervals.
+ *
+ * Tracks the number of Edit/Write operations in a temp file.  Every 20 edits,
+ * it logs a suggestion to stderr reminding the developer to compact context
+ * with /compact.  This helps prevent context window exhaustion during long
+ * editing sessions.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { readStdinJson, log, output, getTempDir, ensureDir, getSessionIdShort } = require('../lib/utils');
+
+const COMPACT_INTERVAL = 20;
+
+function getCounterFile() {
+  const dir = path.join(getTempDir(), 'ecc-infisense');
+  ensureDir(dir);
+  const sessionId = getSessionIdShort('default');
+  return path.join(dir, `edit-counter-${sessionId}.json`);
+}
+
+function loadCounter() {
+  const file = getCounterFile();
+  try {
+    const raw = fs.readFileSync(file, 'utf-8');
+    const data = JSON.parse(raw);
+    return typeof data.count === 'number' ? data.count : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function saveCounter(count) {
+  const file = getCounterFile();
+  fs.writeFileSync(file, JSON.stringify({ count, updatedAt: new Date().toISOString() }), 'utf-8');
+}
+
+async function main() {
+  const data = await readStdinJson();
+
+  const count = loadCounter() + 1;
+  saveCounter(count);
+
+  if (count > 0 && count % COMPACT_INTERVAL === 0) {
+    log('[infisense:suggest-compact] ---- Compaction Suggestion ----');
+    log(`[infisense:suggest-compact] You have made ${count} edits in this session.`);
+    log('[infisense:suggest-compact] Consider running /compact to reduce context size');
+    log('[infisense:suggest-compact] and preserve working memory for the rest of the session.');
+    log('[infisense:suggest-compact] ---- End Suggestion ----');
+  }
+
+  output(data);
+}
+
+main().catch(() => process.exit(0));