844 lines
22 KiB
JavaScript
844 lines
22 KiB
JavaScript
/**
|
||
* Cross-platform Hook shared utility library
|
||
* Provides cross-platform compatible shared functions for Claude Code Hooks
|
||
*
|
||
* @module hook-common
|
||
*/
|
||
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
const { execSync } = require('child_process');
|
||
|
||
/**
|
||
* Get Git status information
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} Git info object
|
||
*/
|
||
function getGitInfo(cwd) {
|
||
try {
|
||
// Check if this is a Git repository
|
||
execSync('git rev-parse --git-dir', {
|
||
cwd,
|
||
stdio: 'pipe'
|
||
});
|
||
|
||
// Get branch name
|
||
let branch = 'unknown';
|
||
try {
|
||
branch = execSync('git branch --show-current', {
|
||
cwd,
|
||
encoding: 'utf8',
|
||
stdio: 'pipe'
|
||
}).trim();
|
||
} catch {
|
||
branch = 'unknown';
|
||
}
|
||
|
||
// Get changed files
|
||
let changes = '';
|
||
try {
|
||
changes = execSync('git status --porcelain', {
|
||
cwd,
|
||
encoding: 'utf8',
|
||
stdio: 'pipe'
|
||
});
|
||
} catch {
|
||
changes = '';
|
||
}
|
||
|
||
const changeList = changes.trim().split('\n').filter(Boolean);
|
||
const hasChanges = changeList.length > 0;
|
||
|
||
return {
|
||
is_repo: true,
|
||
branch,
|
||
changes_count: changeList.length,
|
||
has_changes: hasChanges,
|
||
changes: changeList
|
||
};
|
||
} catch {
|
||
return {
|
||
is_repo: false,
|
||
branch: 'unknown',
|
||
changes_count: 0,
|
||
has_changes: false,
|
||
changes: []
|
||
};
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get todo item information
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} Todo item information
|
||
*/
|
||
function getTodoInfo(cwd) {
|
||
const todoFiles = [
|
||
path.join(cwd, 'docs', 'todo.md'),
|
||
path.join(cwd, 'TODO.md'),
|
||
path.join(cwd, '.claude', 'todos.md'),
|
||
path.join(cwd, 'TODO'),
|
||
path.join(cwd, 'notes', 'todo.md')
|
||
];
|
||
|
||
for (const file of todoFiles) {
|
||
if (fs.existsSync(file)) {
|
||
try {
|
||
const content = fs.readFileSync(file, 'utf8');
|
||
const totalMatches = content.match(/^[\-\*] \[[ x]\]/gi) || [];
|
||
const total = totalMatches.length;
|
||
|
||
const doneMatches = content.match(/^[\-\*] \[x\]/gi) || [];
|
||
const done = doneMatches.length;
|
||
|
||
const pending = total - done;
|
||
|
||
return {
|
||
found: true,
|
||
file: path.basename(file),
|
||
path: file,
|
||
total,
|
||
done,
|
||
pending
|
||
};
|
||
} catch {
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
found: false,
|
||
file: null,
|
||
path: null,
|
||
total: 0,
|
||
done: 0,
|
||
pending: 0
|
||
};
|
||
}
|
||
|
||
|
||
/**
|
||
* Resolve repository root when available
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {string} Repository root or cwd fallback
|
||
*/
|
||
function getRepoRoot(cwd) {
|
||
try {
|
||
return execSync('git rev-parse --show-toplevel', {
|
||
cwd,
|
||
encoding: 'utf8',
|
||
stdio: 'pipe'
|
||
}).trim();
|
||
} catch {
|
||
return cwd;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Parse simple YAML frontmatter from a Markdown file.
|
||
* Supports the project-memory binding metadata shape.
|
||
* @param {string} filePath
|
||
* @returns {Object|null}
|
||
*/
|
||
function parseFrontmatterFile(filePath) {
|
||
try {
|
||
const content = fs.readFileSync(filePath, 'utf8');
|
||
const match = content.match(/^---\n([\s\S]*?)\n---/);
|
||
if (!match) return null;
|
||
|
||
const data = {};
|
||
for (const line of match[1].split('\n')) {
|
||
const parts = line.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
|
||
if (!parts) continue;
|
||
const key = parts[1];
|
||
let value = parts[2].trim();
|
||
|
||
if (value === 'true') value = true;
|
||
else if (value === 'false') value = false;
|
||
else value = value.replace(/^['"]|['"]$/g, '');
|
||
|
||
data[key] = value;
|
||
}
|
||
return data;
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Detect whether the current repository is bound to Obsidian project memory
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} Binding info
|
||
*/
|
||
function getProjectMemoryBinding(cwd) {
|
||
const repoRoot = getRepoRoot(cwd);
|
||
const projectMemoryDir = path.join(repoRoot, '.claude', 'project-memory');
|
||
const registryPath = path.join(projectMemoryDir, 'registry.yaml');
|
||
|
||
if (!fs.existsSync(registryPath)) {
|
||
return {
|
||
bound: false,
|
||
repoRoot,
|
||
registryPath,
|
||
projectId: null,
|
||
status: null,
|
||
autoSync: false,
|
||
vaultRoot: null,
|
||
hubNote: null,
|
||
memoryPath: null
|
||
};
|
||
}
|
||
|
||
let project = null;
|
||
let memoryPath = null;
|
||
|
||
if (fs.existsSync(projectMemoryDir)) {
|
||
const memoryFiles = fs.readdirSync(projectMemoryDir)
|
||
.filter(name => name.endsWith('.md'))
|
||
.map(name => path.join(projectMemoryDir, name));
|
||
|
||
for (const candidate of memoryFiles) {
|
||
const frontmatter = parseFrontmatterFile(candidate);
|
||
if (!frontmatter) continue;
|
||
if (frontmatter.repo_root && (frontmatter.repo_root === repoRoot || cwd.startsWith(frontmatter.repo_root))) {
|
||
project = frontmatter;
|
||
memoryPath = candidate;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!memoryPath && memoryFiles.length > 0) {
|
||
memoryPath = memoryFiles[0];
|
||
project = parseFrontmatterFile(memoryPath) || null;
|
||
}
|
||
}
|
||
|
||
return {
|
||
bound: true,
|
||
repoRoot,
|
||
registryPath,
|
||
projectId: project ? project.project_id || null : null,
|
||
status: project ? project.status || null : null,
|
||
autoSync: Boolean(project && project.auto_sync),
|
||
vaultRoot: project ? project.vault_root || null : null,
|
||
hubNote: project ? project.hub_note || null : null,
|
||
memoryPath
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Heuristically detect whether a directory looks like a research repo
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} Detection result
|
||
*/
|
||
function detectResearchProject(cwd) {
|
||
const repoRoot = getRepoRoot(cwd);
|
||
const markers = [
|
||
'.git',
|
||
'README.md',
|
||
'docs',
|
||
'notes',
|
||
'plan',
|
||
'results',
|
||
'outputs',
|
||
'src',
|
||
'scripts'
|
||
];
|
||
|
||
const hits = markers.filter(marker => fs.existsSync(path.join(repoRoot, marker)));
|
||
const candidate = hits.length >= 3 || (hits.includes('.git') && hits.includes('README.md') && hits.length >= 2);
|
||
|
||
return {
|
||
repoRoot,
|
||
candidate,
|
||
markers: hits
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Detect whether a user prompt looks research-related
|
||
* @param {string} prompt - User prompt
|
||
* @returns {boolean} Whether the prompt looks research-related
|
||
*/
|
||
function promptLooksResearchRelated(prompt) {
|
||
return /\b(obsidian|zotero|paper|papers|literature|review|experiment|results?|finding|analysis|research|plan|todo|daily|meeting|writing|draft|proposal|rebuttal|claim|method)\b|文献|实验|结果|研究|计划|待办|知识库|论文|综述|笔记|项目记忆|obsidian|zotero/i.test(prompt);
|
||
}
|
||
|
||
/**
|
||
* Get Git change details
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} Change statistics
|
||
*/
|
||
function getChangesDetails(cwd) {
|
||
try {
|
||
let added = 0;
|
||
let modified = 0;
|
||
let deleted = 0;
|
||
|
||
// 解析 name-status 输出，每行格式: "A\tfilename" 或 "M\tfilename"
|
||
const parseNameStatus = (output) => {
|
||
for (const line of output.trim().split('\n').filter(Boolean)) {
|
||
const status = line.charAt(0);
|
||
if (status === 'A') added++;
|
||
else if (status === 'M') modified++;
|
||
else if (status === 'D') deleted++;
|
||
}
|
||
};
|
||
|
||
// 工作区变更（unstaged）
|
||
const unstaged = execSync('git diff --name-status', {
|
||
cwd,
|
||
encoding: 'utf8',
|
||
stdio: 'pipe'
|
||
});
|
||
parseNameStatus(unstaged);
|
||
|
||
// 暂存区变更（staged）
|
||
const staged = execSync('git diff --cached --name-status', {
|
||
cwd,
|
||
encoding: 'utf8',
|
||
stdio: 'pipe'
|
||
});
|
||
parseNameStatus(staged);
|
||
|
||
// 未跟踪文件算作 added
|
||
const untracked = execSync('git status --porcelain', {
|
||
cwd,
|
||
encoding: 'utf8',
|
||
stdio: 'pipe'
|
||
});
|
||
for (const line of untracked.trim().split('\n').filter(Boolean)) {
|
||
if (line.startsWith('??')) added++;
|
||
}
|
||
|
||
return { added, modified, deleted };
|
||
} catch {
|
||
return { added: 0, modified: 0, deleted: 0 };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Analyze changes by file type
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} File type statistics
|
||
*/
|
||
function analyzeChangesByType(cwd) {
|
||
const gitInfo = getGitInfo(cwd);
|
||
|
||
if (!gitInfo.is_repo || !gitInfo.has_changes) {
|
||
return {
|
||
test_files: 0,
|
||
docs_files: 0,
|
||
sql_files: 0,
|
||
config_files: 0,
|
||
service_files: 0
|
||
};
|
||
}
|
||
|
||
// 逐行匹配文件路径（git status --porcelain 格式: "XY filename"）
|
||
const files = gitInfo.changes.map(line => line.substring(3).trim());
|
||
|
||
const testRegex = /(?:^|[\/\\])tests?[\/\\]|[\/\\._]test[_.]|\.test\.|_test\./i;
|
||
const docsRegex = /\.(md|txt|rst)$/i;
|
||
const sqlRegex = /\.sql$/i;
|
||
const configRegex = /\.(json|yaml|yml|toml|ini|conf)$/i;
|
||
const serviceRegex = /(service|controller)/i;
|
||
|
||
let testFiles = 0;
|
||
let docsFiles = 0;
|
||
let sqlFiles = 0;
|
||
let configFiles = 0;
|
||
let serviceFiles = 0;
|
||
|
||
for (const file of files) {
|
||
if (testRegex.test(file)) testFiles++;
|
||
if (docsRegex.test(file)) docsFiles++;
|
||
if (sqlRegex.test(file)) sqlFiles++;
|
||
if (configRegex.test(file)) configFiles++;
|
||
if (serviceRegex.test(file)) serviceFiles++;
|
||
}
|
||
|
||
return {
|
||
test_files: testFiles,
|
||
docs_files: docsFiles,
|
||
sql_files: sqlFiles,
|
||
config_files: configFiles,
|
||
service_files: serviceFiles
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Detect temporary files
|
||
* @param {string} cwd - Current working directory
|
||
* @returns {Object} Temporary file information
|
||
*/
|
||
function detectTempFiles(cwd) {
|
||
const tempFiles = new Set();
|
||
const gitInfo = getGitInfo(cwd);
|
||
|
||
// Find temp files from Git untracked files
|
||
if (gitInfo.is_repo) {
|
||
for (const change of gitInfo.changes) {
|
||
if (change.startsWith('??')) {
|
||
const file = change.substring(3).trim();
|
||
if (/plan|draft|tmp|temp|scratch/i.test(file)) {
|
||
tempFiles.add(file);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Check known temporary directories
|
||
const tempDirs = ['plan', 'docs/plans', '.claude/temp', 'tmp', 'temp'];
|
||
for (const dir of tempDirs) {
|
||
const dirPath = path.join(cwd, dir);
|
||
if (fs.existsSync(dirPath)) {
|
||
try {
|
||
const files = getAllFiles(dirPath);
|
||
for (const file of files) {
|
||
tempFiles.add(path.relative(cwd, file));
|
||
}
|
||
} catch {
|
||
// Ignore errors
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
files: Array.from(tempFiles),
|
||
count: tempFiles.size
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Recursively get all files in a directory
|
||
* @param {string} dirPath - Directory path
|
||
* @returns {Array<string>} List of file paths
|
||
*/
|
||
function getAllFiles(dirPath) {
|
||
const files = [];
|
||
const items = fs.readdirSync(dirPath);
|
||
|
||
for (const item of items) {
|
||
const fullPath = path.join(dirPath, item);
|
||
const stat = fs.statSync(fullPath);
|
||
|
||
if (stat.isDirectory()) {
|
||
files.push(...getAllFiles(fullPath));
|
||
} else {
|
||
files.push(fullPath);
|
||
}
|
||
}
|
||
|
||
return files;
|
||
}
|
||
|
||
/**
|
||
* Generate smart recommendations
|
||
* @param {string} cwd - Current working directory
|
||
* @param {Object} gitInfo - Git information
|
||
* @returns {Array<string>} List of recommendations
|
||
*/
|
||
function generateRecommendations(cwd, gitInfo) {
|
||
const recommendations = [];
|
||
|
||
if (gitInfo.is_repo && gitInfo.has_changes) {
|
||
const changesDetails = getChangesDetails(cwd);
|
||
const typeAnalysis = analyzeChangesByType(cwd);
|
||
|
||
if (changesDetails.added > 0 || changesDetails.modified > 0) {
|
||
recommendations.push('git add . && git commit -m "feat: xxx"');
|
||
}
|
||
|
||
if (typeAnalysis.test_files > 0) {
|
||
recommendations.push('Run test suite to verify changes');
|
||
}
|
||
if (typeAnalysis.docs_files > 0) {
|
||
recommendations.push('Check documentation is in sync with code');
|
||
}
|
||
if (typeAnalysis.sql_files > 0) {
|
||
recommendations.push('Update all related database scripts');
|
||
}
|
||
if (typeAnalysis.config_files > 0) {
|
||
recommendations.push('Check if environment variables need updating');
|
||
}
|
||
if (typeAnalysis.service_files > 0) {
|
||
recommendations.push('Update API documentation');
|
||
}
|
||
}
|
||
|
||
// Todo reminder
|
||
const todoInfo = getTodoInfo(cwd);
|
||
if (todoInfo.found && todoInfo.pending > 0) {
|
||
recommendations.push(`Check todos: ${todoInfo.file} (${todoInfo.pending} items remaining)`);
|
||
}
|
||
|
||
// Non-repo environment reminder
|
||
if (!gitInfo.is_repo) {
|
||
recommendations.push('Remember to back up important files to a git repo or cloud storage');
|
||
}
|
||
|
||
return recommendations;
|
||
}
|
||
|
||
/**
|
||
* Get list of enabled plugins
|
||
* @param {string} homeDir - User home directory
|
||
* @returns {Array<Object>} Plugin list
|
||
*/
|
||
function getEnabledPlugins(homeDir) {
|
||
const settingsFile = path.join(homeDir, '.claude', 'settings.json');
|
||
|
||
if (!fs.existsSync(settingsFile)) {
|
||
return [];
|
||
}
|
||
|
||
try {
|
||
const settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8'));
|
||
const enabledPlugins = settings.enabledPlugins || {};
|
||
|
||
const plugins = [];
|
||
for (const [pluginId, enabled] of Object.entries(enabledPlugins)) {
|
||
if (enabled) {
|
||
const pluginName = pluginId.split('@')[0];
|
||
plugins.push({
|
||
id: pluginId,
|
||
name: pluginName
|
||
});
|
||
}
|
||
}
|
||
|
||
return plugins;
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Get list of available commands
|
||
* @param {string} homeDir - User home directory
|
||
* @returns {Array<Object>} Command list
|
||
*/
|
||
function getAvailableCommands(homeDir) {
|
||
const commands = [];
|
||
|
||
// Only collect local commands, not plugin commands
|
||
const localCommandsDir = path.join(homeDir, '.claude', 'commands');
|
||
if (fs.existsSync(localCommandsDir)) {
|
||
const commandFiles = fs.readdirSync(localCommandsDir)
|
||
.filter(f => f.endsWith('.md'));
|
||
|
||
for (const cmdFile of commandFiles) {
|
||
const cmdName = cmdFile.replace('.md', '');
|
||
commands.push({
|
||
plugin: 'local',
|
||
name: cmdName,
|
||
path: path.join(localCommandsDir, cmdFile)
|
||
});
|
||
}
|
||
}
|
||
|
||
return commands;
|
||
}
|
||
|
||
/**
|
||
* Get command description
|
||
* @param {string} cmdPath - Command file path
|
||
* @returns {string} Command description
|
||
*/
|
||
function getCommandDescription(cmdPath) {
|
||
try {
|
||
const content = fs.readFileSync(cmdPath, 'utf8');
|
||
const lines = content.split('\n');
|
||
|
||
// Try to get description from frontmatter
|
||
let inFrontmatter = false;
|
||
for (const line of lines) {
|
||
if (line.trim() === '---') {
|
||
if (!inFrontmatter) {
|
||
inFrontmatter = true;
|
||
} else {
|
||
break;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (inFrontmatter && line.trim().startsWith('description:')) {
|
||
const match = line.match(/description:\s*["']?(.+?)["']?$/);
|
||
if (match) {
|
||
return match[1].trim();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Try to get from heading
|
||
for (const line of lines) {
|
||
const match = line.match(/^#+\s*(.+)$/);
|
||
if (match) {
|
||
return match[1].trim().substring(0, 50);
|
||
}
|
||
}
|
||
|
||
return '';
|
||
} catch {
|
||
return '';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Collect local skills
|
||
* @param {string} homeDir - User home directory
|
||
* @returns {Array<Object>} Skill list
|
||
*/
|
||
function collectLocalSkills(homeDir) {
|
||
const skills = [];
|
||
const skillsDir = path.join(homeDir, '.claude', 'skills');
|
||
|
||
if (!fs.existsSync(skillsDir)) {
|
||
return skills;
|
||
}
|
||
|
||
const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
|
||
.filter(d => d.isDirectory())
|
||
.map(d => d.name);
|
||
|
||
for (const skillName of skillDirs) {
|
||
const skillFile = path.join(skillsDir, skillName, 'SKILL.md');
|
||
let description = '';
|
||
|
||
if (fs.existsSync(skillFile)) {
|
||
try {
|
||
const content = fs.readFileSync(skillFile, 'utf8');
|
||
const match = content.match(/description:\s*(.+)$/im);
|
||
if (match) {
|
||
description = match[1].trim();
|
||
}
|
||
} catch {
|
||
// Ignore
|
||
}
|
||
}
|
||
|
||
skills.push({
|
||
name: skillName,
|
||
description,
|
||
type: 'local'
|
||
});
|
||
}
|
||
|
||
return skills;
|
||
}
|
||
|
||
/**
|
||
* Collect plugin skills
|
||
* @param {string} homeDir - User home directory
|
||
* @returns {Array<Object>} Skill list
|
||
*/
|
||
function collectPluginSkills(homeDir) {
|
||
const skills = [];
|
||
const pluginsCache = path.join(homeDir, '.claude', 'plugins', 'cache');
|
||
|
||
if (!fs.existsSync(pluginsCache)) {
|
||
return skills;
|
||
}
|
||
|
||
const marketplaces = fs.readdirSync(pluginsCache, { withFileTypes: true })
|
||
.filter(d => d.isDirectory())
|
||
.map(d => d.name);
|
||
|
||
for (const marketplace of marketplaces) {
|
||
// Skip ai-research-skills
|
||
if (marketplace === 'ai-research-skills') continue;
|
||
|
||
const marketplacePath = path.join(pluginsCache, marketplace);
|
||
const plugins = fs.readdirSync(marketplacePath, { withFileTypes: true })
|
||
.filter(d => d.isDirectory() && !d.name.startsWith('.'))
|
||
.map(d => d.name);
|
||
|
||
for (const plugin of plugins) {
|
||
const pluginPath = path.join(marketplacePath, plugin);
|
||
const versions = fs.readdirSync(pluginPath, { withFileTypes: true })
|
||
.filter(d => d.isDirectory())
|
||
.map(d => d.name)
|
||
.sort()
|
||
.reverse();
|
||
|
||
if (versions.length === 0) continue;
|
||
|
||
const latestVersion = versions[0];
|
||
const pluginRoot = path.join(pluginPath, latestVersion);
|
||
const skillsDir = path.join(pluginRoot, 'skills');
|
||
|
||
if (fs.existsSync(skillsDir)) {
|
||
const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
|
||
.filter(d => d.isDirectory())
|
||
.map(d => d.name);
|
||
|
||
for (const skillName of skillDirs) {
|
||
skills.push({
|
||
name: `${plugin}:${skillName}`,
|
||
plugin,
|
||
skill: skillName,
|
||
type: 'plugin'
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return skills;
|
||
}
|
||
|
||
/**
|
||
* Format date and time
|
||
* @param {Date} date - Date object
|
||
* @returns {string} Formatted date-time string
|
||
*/
|
||
function formatDateTime(date = new Date()) {
|
||
const year = date.getFullYear();
|
||
const month = String(date.getMonth() + 1).padStart(2, '0');
|
||
const day = String(date.getDate()).padStart(2, '0');
|
||
const hours = String(date.getHours()).padStart(2, '0');
|
||
const minutes = String(date.getMinutes()).padStart(2, '0');
|
||
const seconds = String(date.getSeconds()).padStart(2, '0');
|
||
|
||
return `${year}/${month}/${day} ${hours}:${minutes}:${seconds}`;
|
||
}
|
||
|
||
/**
|
||
* Check if CLAUDE.md needs updating
|
||
* @param {string} homeDir - User home directory
|
||
* @returns {Object} Check result
|
||
*/
|
||
function checkClaudeMdUpdate(homeDir) {
|
||
const claudeMdPath = path.join(homeDir, '.claude', 'CLAUDE.md');
|
||
const lastSyncPath = path.join(homeDir, '.claude', '.last-memory-sync');
|
||
|
||
// If CLAUDE.md does not exist, return immediately
|
||
if (!fs.existsSync(claudeMdPath)) {
|
||
return { needsUpdate: false, reason: 'CLAUDE.md not found' };
|
||
}
|
||
|
||
// Get CLAUDE.md modification time
|
||
const claudeMdMtime = fs.statSync(claudeMdPath).mtimeMs;
|
||
|
||
// Get last sync time (use CLAUDE.md creation time if not available)
|
||
let lastSyncMtime = claudeMdMtime;
|
||
if (fs.existsSync(lastSyncPath)) {
|
||
try {
|
||
lastSyncMtime = parseInt(fs.readFileSync(lastSyncPath, 'utf8').trim(), 10);
|
||
} catch {
|
||
lastSyncMtime = claudeMdMtime;
|
||
}
|
||
}
|
||
|
||
const referenceTime = Math.max(claudeMdMtime, lastSyncMtime);
|
||
|
||
// Define source file directories to monitor
|
||
const sourceDirs = [
|
||
{ dir: path.join(homeDir, '.claude', 'skills'), pattern: /SKILL\.md$/, type: 'skill' },
|
||
{ dir: path.join(homeDir, '.claude', 'commands'), pattern: /\.md$/, type: 'command' },
|
||
{ dir: path.join(homeDir, '.claude', 'agents'), pattern: /\.md$/, type: 'agent' },
|
||
{ dir: path.join(homeDir, '.claude', 'hooks'), pattern: /\.(js|json)$/, type: 'hook' }
|
||
];
|
||
|
||
const changedFiles = [];
|
||
let totalSkills = 0;
|
||
let totalCommands = 0;
|
||
let totalAgents = 0;
|
||
let totalHooks = 0;
|
||
|
||
// Scan each source directory
|
||
for (const { dir, pattern, type } of sourceDirs) {
|
||
if (!fs.existsSync(dir)) continue;
|
||
|
||
const files = getAllFiles(dir).filter(f => pattern.test(f));
|
||
|
||
for (const file of files) {
|
||
try {
|
||
const mtime = fs.statSync(file).mtimeMs;
|
||
|
||
// Count totals
|
||
if (type === 'skill') totalSkills++;
|
||
else if (type === 'command') totalCommands++;
|
||
else if (type === 'agent') totalAgents++;
|
||
else if (type === 'hook') totalHooks++;
|
||
|
||
// Check if newer than reference time
|
||
if (mtime > referenceTime) {
|
||
changedFiles.push({
|
||
path: file,
|
||
type,
|
||
relativePath: path.relative(homeDir, file),
|
||
mtime: new Date(mtime).toLocaleString('en-US')
|
||
});
|
||
}
|
||
} catch {
|
||
// Ignore inaccessible files
|
||
}
|
||
}
|
||
}
|
||
|
||
return {
|
||
needsUpdate: changedFiles.length > 0,
|
||
changedFiles,
|
||
stats: {
|
||
skills: totalSkills,
|
||
commands: totalCommands,
|
||
agents: totalAgents,
|
||
hooks: totalHooks
|
||
},
|
||
claudeMdMtime: new Date(claudeMdMtime).toLocaleString('en-US'),
|
||
lastSyncMtime: new Date(lastSyncMtime).toLocaleString('en-US')
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Update sync timestamp
|
||
* @param {string} homeDir - User home directory
|
||
*/
|
||
function updateSyncTimestamp(homeDir) {
|
||
const lastSyncPath = path.join(homeDir, '.claude', '.last-memory-sync');
|
||
try {
|
||
fs.writeFileSync(lastSyncPath, Date.now().toString(), 'utf8');
|
||
} catch {
|
||
// Ignore write errors
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Create a temporary file
|
||
* @param {string} prefix - Filename prefix
|
||
* @returns {string} Temporary file path
|
||
*/
|
||
function createTempFile(prefix = 'claude-temp') {
|
||
const os = require('os');
|
||
const tmpDir = os.tmpdir();
|
||
const randomSuffix = Math.random().toString(36).substring(2, 8);
|
||
return path.join(tmpDir, `${prefix}-${randomSuffix}.tmp`);
|
||
}
|
||
|
||
// Export all functions
|
||
module.exports = {
|
||
getGitInfo,
|
||
getTodoInfo,
|
||
getRepoRoot,
|
||
getProjectMemoryBinding,
|
||
detectResearchProject,
|
||
promptLooksResearchRelated,
|
||
getChangesDetails,
|
||
analyzeChangesByType,
|
||
detectTempFiles,
|
||
generateRecommendations,
|
||
getEnabledPlugins,
|
||
getAvailableCommands,
|
||
getCommandDescription,
|
||
collectLocalSkills,
|
||
collectPluginSkills,
|
||
formatDateTime,
|
||
createTempFile,
|
||
getAllFiles,
|
||
checkClaudeMdUpdate,
|
||
updateSyncTimestamp
|
||
};
|