@thanhthi2895/luna-ai 2.16.2

package/agentic/claude/.claude/hooks/descriptive-name.cjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * Descriptive Name Hook - PreToolUse (Write)
+ *
+ * Fires before Write operations to inject file naming guidance.
+ * Encourages self-documenting names following language conventions.
+ *
+ * Luna AI
+ */
+
+// Crash wrapper
+try {
+  const { isHookEnabled } = require('./lib/luna-config-utils.cjs');
+
+  if (!isHookEnabled('descriptive-name')) {
+    process.exit(0);
+  }
+
+  try {
+  let injectedPrompt = `## File naming guidance:
+- Skip this guidance if you are creating markdown or plain text files
+- Prefer kebab-case for JS/TS/Python/shell (.js, .ts, .py, .sh) with descriptive names
+- Respect language conventions: C#/Java/Kotlin/Swift use PascalCase (.cs, .java, .kt, .swift), Go/Rust use snake_case (.go, .rs)
+- Other languages: follow their ecosystem's standard naming convention
+- Goal: self-documenting names for LLM tools (Grep, Glob, Search)`;
+
+  console.log(JSON.stringify({
+    "hookSpecificOutput": {
+      "hookEventName": "PreToolUse",
+      "permissionDecision": "allow",
+      "additionalContext": injectedPrompt
+    }
+  }));
+
+    process.exit(0);
+
+  } catch (error) {
+    console.error('WARN: Hook error, allowing operation -', error.message);
+    process.exit(0);
+  }
+} catch (e) {
+  // Minimal crash logging
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'descriptive-name', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/agentic/claude/.claude/hooks/dev-rules-reminder.cjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * dev-rules-reminder.cjs — Luna UserPromptSubmit Hook
+ *
+ * Injects: active plan context + dev rules reminder into each prompt.
+ * Throttled: doesn't inject more than once per 5 minutes per session.
+ *
+ * Exit Codes: 0 (non-blocking)
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const { buildReminderContext, wasRecentlyInjected } = require('./lib/context-builder.cjs');
+  const { isHookEnabled } = require('./lib/luna-config-utils.cjs');
+
+  if (!isHookEnabled('dev-rules-reminder')) process.exit(0);
+
+  async function main() {
+    try {
+      const stdin = fs.readFileSync(0, 'utf-8').trim();
+      if (!stdin) process.exit(0);
+
+      const payload = JSON.parse(stdin);
+      const transcriptPath = payload.transcript_path || null;
+
+      // Throttle: don't inject if was recently injected
+      if (transcriptPath && wasRecentlyInjected(transcriptPath)) {
+        process.exit(0);
+      }
+
+      const sessionId = payload.session_id || process.env.LUNA_SESSION_ID || null;
+      const baseDir = process.cwd();
+
+      const { content } = buildReminderContext({ sessionId, baseDir });
+
+      console.log(content);
+      process.exit(0);
+    } catch (error) {
+      console.error(`[dev-rules-reminder] Error: ${error.message}`);
+      process.exit(0);
+    }
+  }
+
+  main();
+} catch (e) {
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'dev-rules-reminder', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/agentic/claude/.claude/hooks/lib/context-builder.cjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+/**
+ * context-builder.cjs — Build context strings for Luna reminder hooks
+ *
+ * Used by: dev-rules-reminder.cjs, subagent-init.cjs
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const { loadConfig, resolvePlanPath, getReportsPath, resolveNamingPattern } = require('./luna-config-utils.cjs');
+
+const USAGE_CACHE = path.join(os.tmpdir(), 'luna-usage-limits-cache.json');
+const WARN = 70, CRIT = 90;
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function execSafe(cmd) {
+  try { return execSync(cmd, { encoding: 'utf8', stdio: 'pipe' }).trim(); } catch { return null; }
+}
+
+/** Throttle via transcript scan — more reliable than temp file timestamp */
+function wasRecentlyInjected(transcriptPath) {
+  try {
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) return false;
+    return fs.readFileSync(transcriptPath, 'utf-8').split('\n').slice(-150)
+      .some(l => l.includes('[IMPORTANT] Consider Modularization'));
+  } catch { return false; }
+}
+
+/** Resolve skills venv from global runtime only (CLAUDE_CONFIG_DIR or ~/.claude). */
+function resolveSkillsVenv() {
+  const isWin = process.platform === 'win32';
+  const bin = isWin ? 'Scripts' : 'bin';
+  const exe = isWin ? 'python.exe' : 'python3';
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const global_ = path.join(claudeConfigDir, 'skills', '.venv', bin, exe);
+  if (!fs.existsSync(global_)) return null;
+  if (process.env.CLAUDE_CONFIG_DIR) return path.join(process.env.CLAUDE_CONFIG_DIR, 'skills', '.venv', bin, exe);
+  return isWin ? '~\\.claude\\skills\\.venv\\Scripts\\python.exe' : '~/.claude/skills/.venv/bin/python3';
+}
+
+function resolveSkillsPath() {
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const global_ = path.join(claudeConfigDir, 'skills');
+  return fs.existsSync(global_) ? global_ : null;
+}
+
+// ── Section builders ─────────────────────────────────────────────────────────
+
+function buildLanguageSection({ thinkingLanguage, responseLanguage }) {
+  const thinking = thinkingLanguage || (responseLanguage ? 'en' : null);
+  if (!thinking && !responseLanguage) return [];
+  const lines = ['## Language'];
+  if (thinking && thinking !== responseLanguage) lines.push(`- Thinking: Use ${thinking} for reasoning (logic, precision).`);
+  // if (responseLanguage) lines.push(`- Response: Respond in ${responseLanguage} (natural, fluent).`);
+  return [...lines, ''];
+}
+
+function buildContextSection(sessionId) {
+  if (!sessionId) return [];
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(os.tmpdir(), `luna-context-${sessionId}.json`), 'utf-8'));
+    if (Date.now() - d.timestamp > 300000) return [];
+    const lines = [
+      '## Context Window',
+      `- Usage: ${d.percent}% (${Math.round(d.tokens / 1000)}K/${Math.round(d.size / 1000)}K tokens)`,
+      '- **NOTE:** Optimize workflow for token efficiency',
+    ];
+    if (d.percent >= CRIT) lines.push('- **CRITICAL:** Context nearly full — compact or be concise, update phase status first.');
+    else if (d.percent >= WARN) lines.push('- **WARNING:** Context high — be concise and efficient.');
+    return [...lines, ''];
+  } catch { return []; }
+}
+
+function buildUsageSection() {
+  try {
+    const c = JSON.parse(fs.readFileSync(USAGE_CACHE, 'utf-8'));
+    if (!c.data || Date.now() - c.timestamp > 300000) return [];
+    const fmt = (v, l) => v >= CRIT ? `${l}: ${Math.round(v)}% [CRITICAL]` : v >= WARN ? `${l}: ${Math.round(v)}% [WARNING]` : `${l}: ${Math.round(v)}%`;
+    const parts = [];
+    if (c.data.five_hour?.utilization != null) parts.push(fmt(c.data.five_hour.utilization, '5h'));
+    if (c.data.seven_day?.utilization != null) parts.push(fmt(c.data.seven_day.utilization, '7d'));
+    return parts.length ? ['## Usage Limits', `- ${parts.join(' | ')}`, ''] : [];
+  } catch { return []; }
+}
+
+function buildRulesSection({ skillsVenv, plansPath, docsPath }) {
+  const lines = [
+    '## Rules',
+    '- Read and follow: `${CLAUDE_CONFIG_DIR:-~/.claude}/rules/development-rules.md`',
+    `- Plans → "${plansPath}" | Docs → "${docsPath}" — DO NOT create markdown files outside these.`,
+  ];
+  if (skillsVenv) lines.push(`- Python scripts (skills): use \`${skillsVenv}\``);
+  lines.push('- **Skills**: use `Skill` tool to invoke (load via `ToolSearch` first). See CLAUDE.md → "How to Use Skills".');
+  lines.push('- Follow YAGNI / KISS / DRY — no unnecessary complexity.');
+  lines.push('- Sacrifice grammar for concision in reports. List unresolved questions at end.');
+  return [...lines, ''];
+}
+
+function buildModularizationSection() {
+  return [
+    '## **[IMPORTANT] Consider Modularization:**',
+    '- If file exceeds 200 lines, split into modules',
+    '- Check existing modules before creating new',
+    '- Use kebab-case naming (descriptive, self-documenting)',
+    '- Write descriptive code comments',
+    '- When not to modularize: Markdown, plain text, bash scripts, config files, env files',
+    '',
+  ];
+}
+
+function buildPathsSection({ reportsPath, plansPath, docsPath }) {
+  return ['## Paths', `Reports: ${reportsPath} | Plans: ${plansPath}/ | Docs: ${docsPath}/`, ''];
+}
+
+function buildPlanSection({ planPath, reportsPath, gitBranch }) {
+  if (!planPath) return [];
+  const lines = [
+    '## Active Plan',
+    `- Plan: ${path.basename(planPath)}`,
+    `- Path: ${planPath}`,
+    `- Reports: ${reportsPath}`,
+  ];
+  if (gitBranch) lines.push(`- Branch: ${gitBranch}`);
+  return [...lines, ''];
+}
+
+function buildNamingSection({ reportsPath, plansPath, namePattern }) {
+  return [
+    '## Naming',
+    `- Report: \`${reportsPath}{type}-${namePattern}.md\``,
+    `- Plan dir: \`${plansPath}/${namePattern}/\``,
+    '- Replace `{type}` with agent name or report type; `{slug}` with descriptive-kebab-slug',
+  ];
+}
+
+// ── Main entry point ──────────────────────────────────────────────────────────
+
+function buildReminderContext({ sessionId, baseDir } = {}) {
+  const config = loadConfig();
+  const gitBranch = execSafe('git branch --show-current');
+  const resolved = resolvePlanPath(sessionId, config);
+  const reportsPath = getReportsPath(resolved.path, config);
+  const base = baseDir || process.cwd();
+  const plansPath = path.join(base, config.paths?.plans || 'plans');
+  const docsPath = path.join(base, config.paths?.docs || 'docs');
+  const namePattern = resolveNamingPattern(config.plan);
+  const skillsVenv = resolveSkillsVenv();
+  const hooks = config.hooks || {};
+
+  const lines = [
+    ...buildLanguageSection({ thinkingLanguage: config.locale?.thinkingLanguage, responseLanguage: config.locale?.responseLanguage }),
+    ...(hooks['usage-context-awareness'] !== false ? buildContextSection(sessionId) : []),
+    ...(hooks['usage-context-awareness'] !== false ? buildUsageSection() : []),
+    ...buildRulesSection({ skillsVenv, plansPath, docsPath }),
+    ...buildModularizationSection(),
+    ...buildPathsSection({ reportsPath, plansPath, docsPath }),
+    ...buildPlanSection({ planPath: resolved.path, reportsPath, gitBranch }),
+    ...buildNamingSection({ reportsPath: reportsPath + '/', plansPath, namePattern }),
+  ];
+
+  return { content: lines.join('\n') };
+}
+
+module.exports = {
+  wasRecentlyInjected,
+  buildReminderContext,
+  resolveSkillsVenv,
+  resolveSkillsPath,
+};

package/agentic/claude/.claude/hooks/lib/git-info-cache.cjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Git Info Cache - Cross-platform git information batching
+ *
+ * Problem: Multiple git process spawns per statusline render are slow
+ * Solution: Cache git query results for 30 seconds — subsequent renders read cache
+ *
+ * Performance: event-driven refresh + 30s TTL fallback
+ * Cross-platform: No bash-only syntax, windowsHide on all exec calls
+ *
+ * Luna AI
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Cache TTL — long fallback for external changes (git checkout outside Claude)
+// Active invalidation happens via PostToolUse hooks after Edit/Write/Bash
+const CACHE_TTL = 30000;
+const CACHE_MISS = Symbol('cache_miss');
+
+/**
+ * Safe command execution wrapper with optional cwd
+ */
+function execIn(cmd, cwd) {
+  try {
+    return execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+      windowsHide: true,
+      cwd: cwd || undefined
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Get cache file path for current working directory
+ */
+function getCachePath(cwd) {
+  const hash = require('crypto')
+    .createHash('md5')
+    .update(cwd)
+    .digest('hex')
+    .slice(0, 8);
+  return path.join(os.tmpdir(), `luna-git-cache-${hash}.json`);
+}
+
+/**
+ * Read cache if valid (not expired). Returns CACHE_MISS on miss.
+ */
+function readCache(cachePath) {
+  try {
+    const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+    if (Date.now() - cache.timestamp < CACHE_TTL) {
+      return cache.data; // Can be null (non-git dir) or object (git info)
+    }
+  } catch {
+    // File missing, corrupted, or expired — all treated as cache miss
+  }
+  return CACHE_MISS;
+}
+
+/**
+ * Write cache atomically (temp file + rename to avoid partial reads)
+ */
+function writeCache(cachePath, data) {
+  const tmpPath = cachePath + '.tmp';
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify({ timestamp: Date.now(), data }));
+    fs.renameSync(tmpPath, cachePath);
+  } catch {
+    try { fs.unlinkSync(tmpPath); } catch {}
+  }
+}
+
+/**
+ * Count non-empty lines in a newline-delimited string
+ */
+function countLines(str) {
+  if (!str) return 0;
+  return str.split('\n').filter(l => l.trim()).length;
+}
+
+/**
+ * Fetch git info directly in-process
+ * @param {string} cwd - Directory to run git commands in
+ * Returns: { branch, unstaged, staged, ahead, behind } or null if not git repo
+ */
+function fetchGitInfo(cwd) {
+  if (!execIn('git rev-parse --git-dir', cwd)) {
+    return null;
+  }
+
+  const branch = execIn('git branch --show-current', cwd) || execIn('git rev-parse --short HEAD', cwd);
+  const unstaged = countLines(execIn('git diff --name-only', cwd));
+  const staged = countLines(execIn('git diff --cached --name-only', cwd));
+
+  let ahead = 0, behind = 0;
+  const aheadBehind = execIn('git rev-list --left-right --count @{u}...HEAD', cwd);
+  if (aheadBehind) {
+    const parts = aheadBehind.split(/\s+/);
+    behind = parseInt(parts[0], 10) || 0;
+    ahead = parseInt(parts[1], 10) || 0;
+  }
+
+  return { branch, unstaged, staged, ahead, behind };
+}
+
+/**
+ * Get git info with caching
+ * Main export function used by statusline
+ */
+function getGitInfo(cwd = process.cwd()) {
+  const cachePath = getCachePath(cwd);
+
+  const cached = readCache(cachePath);
+  if (cached !== CACHE_MISS) return cached;
+
+  const data = fetchGitInfo(cwd);
+  writeCache(cachePath, data);
+
+  return data;
+}
+
+/**
+ * Invalidate cache for a directory (call after file changes to trigger fresh git query)
+ */
+function invalidateCache(cwd = process.cwd()) {
+  try { fs.unlinkSync(getCachePath(cwd)); } catch {}
+}
+
+module.exports = { getGitInfo, invalidateCache };

package/agentic/claude/.claude/hooks/lib/luna-config-resolver.cjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+/**
+ * luna-config-resolver.cjs — Shared Luna runtime config resolver
+ *
+ * Lookup order (first valid JSON wins):
+ *   1) ~/.claude/.luna.json (global)
+ *   2) hardcoded defaults
+ *
+ * Workspace lookup is opt-in via includeWorkspace=true.
+ *
+ * Fail-open behavior:
+ * - Missing file => continue
+ * - Malformed JSON => continue
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const LUNA_CONFIG_FILENAME = '.luna.json';
+
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+}
+
+const DEFAULT_LUNA_CONFIG = {
+  plan: {
+    namingFormat: '{date}-{slug}',
+    dateFormat: 'YYYY-MM-DD',
+    reportsDir: 'reports',
+    resolution: { order: ['session', 'branch'] },
+  },
+  paths: { docs: 'docs', plans: 'plans' },
+  locale: { thinkingLanguage: null, responseLanguage: null },
+  hooks: {},
+  assertions: [],
+};
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function deepMerge(target, source) {
+  const result = Object.assign({}, target);
+  for (const key of Object.keys(source || {})) {
+    const sourceValue = source[key];
+    if (isPlainObject(sourceValue)) {
+      result[key] = deepMerge(isPlainObject(target?.[key]) ? target[key] : {}, sourceValue);
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+
+function readJsonFile(filePath) {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function collectWorkspaceCandidates(startDir, searchParents, maxParentDepth) {
+  const candidates = [];
+  let dir = startDir;
+  let depth = 0;
+
+  while (dir) {
+    candidates.push(path.join(dir, LUNA_CONFIG_FILENAME));
+
+    if (!searchParents || depth >= maxParentDepth) break;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+    depth += 1;
+  }
+
+  return candidates;
+}
+
+/**
+ * Resolve Luna runtime config.
+ *
+ * @param {Object} [options]
+ * @param {string} [options.cwd=process.cwd()]
+ * @param {boolean} [options.includeWorkspace=false]
+ * @param {boolean} [options.includeGlobal=true]
+ * @param {boolean} [options.searchParents=false] - only for workspace candidates
+ * @param {number} [options.maxParentDepth=3]
+ * @param {string} [options.globalConfigPath]
+ * @returns {{config: Object, resolvedFrom: 'workspace'|'global'|'defaults', configPath: string|null}}
+ */
+function resolveLunaConfig(options = {}) {
+  const cwd = (typeof options.cwd === 'string' && options.cwd.trim()) || process.cwd();
+  const includeWorkspace = options.includeWorkspace === true;
+  const includeGlobal = options.includeGlobal !== false;
+  const searchParents = options.searchParents === true;
+  const maxParentDepth = Number.isInteger(options.maxParentDepth)
+    ? Math.max(0, options.maxParentDepth)
+    : 3;
+
+  const defaults = deepMerge(DEFAULT_LUNA_CONFIG, options.defaults || {});
+
+  const workspaceCandidates = [];
+  if (includeWorkspace) {
+    for (const configPath of collectWorkspaceCandidates(cwd, searchParents, maxParentDepth)) {
+      workspaceCandidates.push({ resolvedFrom: 'workspace', configPath });
+    }
+  }
+
+  const globalCandidate = includeGlobal
+    ? {
+        resolvedFrom: 'global',
+        configPath: options.globalConfigPath || path.join(getClaudeConfigDir(), LUNA_CONFIG_FILENAME),
+      }
+    : null;
+
+  let globalRaw = null;
+  if (globalCandidate) {
+    globalRaw = readJsonFile(globalCandidate.configPath);
+  }
+
+  for (const candidate of workspaceCandidates) {
+    const raw = readJsonFile(candidate.configPath);
+    if (!isPlainObject(raw)) continue;
+
+    const merged = isPlainObject(globalRaw) ? deepMerge(globalRaw, raw) : raw;
+    return {
+      config: deepMerge(defaults, merged),
+      resolvedFrom: candidate.resolvedFrom,
+      configPath: candidate.configPath,
+    };
+  }
+
+  if (isPlainObject(globalRaw)) {
+    return {
+      config: deepMerge(defaults, globalRaw),
+      resolvedFrom: 'global',
+      configPath: globalCandidate.configPath,
+    };
+  }
+
+  return {
+    config: defaults,
+    resolvedFrom: 'defaults',
+    configPath: null,
+  };
+}
+
+module.exports = {
+  resolveLunaConfig,
+  DEFAULT_LUNA_CONFIG,
+  deepMerge,
+};