synap 0.1.0

package/src/deletion-log.js

@@ -0,0 +1,105 @@
+/**
+ * deletion-log.js - Audit logging for deleted entries, enables restore
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Storage directory
+const CONFIG_DIR = process.env.SYNAP_DIR || path.join(os.homedir(), '.config', 'synap');
+const DELETION_LOG_FILE = path.join(CONFIG_DIR, 'deletion-log.json');
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Atomic file write
+ */
+function atomicWriteSync(filePath, data) {
+  const tmpPath = filePath + '.tmp';
+  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+  fs.renameSync(tmpPath, filePath);
+}
+
+/**
+ * Load deletion log
+ */
+function loadLog() {
+  ensureConfigDir();
+  if (!fs.existsSync(DELETION_LOG_FILE)) {
+    return [];
+  }
+  try {
+    return JSON.parse(fs.readFileSync(DELETION_LOG_FILE, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Save deletion log
+ */
+function saveLog(log) {
+  ensureConfigDir();
+  atomicWriteSync(DELETION_LOG_FILE, log);
+}
+
+/**
+ * Log entries before deletion
+ * Each entry gets a deletedAt timestamp for tracking
+ */
+async function logDeletions(entries) {
+  const log = loadLog();
+  const now = new Date().toISOString();
+
+  for (const entry of entries) {
+    log.unshift({
+      ...entry,
+      deletedAt: now
+    });
+  }
+
+  // Keep last 1000 deletions
+  if (log.length > 1000) {
+    log.length = 1000;
+  }
+
+  saveLog(log);
+}
+
+/**
+ * Get deletion log
+ */
+async function getLog() {
+  return loadLog();
+}
+
+/**
+ * Remove entries from deletion log after restore
+ */
+async function removeFromLog(ids) {
+  const log = loadLog();
+  const filtered = log.filter(e => !ids.some(id => e.id === id || e.id.startsWith(id)));
+  saveLog(filtered);
+}
+
+/**
+ * Clear the entire deletion log
+ */
+async function clearLog() {
+  saveLog([]);
+}
+
+module.exports = {
+  logDeletions,
+  getLog,
+  removeFromLog,
+  clearLog
+};

package/src/preferences.js

@@ -0,0 +1,175 @@
+/**
+ * preferences.js - User preferences storage and helpers
+ */
+
+const fs = require('fs');
+const path = require('path');
+const storage = require('./storage');
+
+const TEMPLATE_PATH = path.join(__dirname, 'templates', 'user-preferences-template.md');
+const PREFERENCES_FILE = path.join(storage.CONFIG_DIR, 'user-preferences.md');
+const MAX_LINES = 500;
+
+function ensureConfigDir() {
+  if (!fs.existsSync(storage.CONFIG_DIR)) {
+    fs.mkdirSync(storage.CONFIG_DIR, { recursive: true });
+  }
+}
+
+function getPreferencesPath() {
+  return PREFERENCES_FILE;
+}
+
+function readTemplate() {
+  if (!fs.existsSync(TEMPLATE_PATH)) {
+    throw new Error(`Preferences template not found: ${TEMPLATE_PATH}`);
+  }
+  return fs.readFileSync(TEMPLATE_PATH, 'utf8');
+}
+
+function validatePreferences(content) {
+  if (typeof content !== 'string') {
+    return { valid: false, error: 'Preferences must be a string' };
+  }
+
+  if (content.includes('\0')) {
+    return { valid: false, error: 'Preferences contain invalid null bytes' };
+  }
+
+  const trimmedContent = content.replace(/(\r?\n)+$/, '');
+  const lineCount = trimmedContent.split(/\r?\n/).length;
+  if (lineCount > MAX_LINES) {
+    return { valid: false, error: `Preferences must be ${MAX_LINES} lines or fewer` };
+  }
+
+  return { valid: true };
+}
+
+function savePreferences(content) {
+  const validation = validatePreferences(content);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+
+  ensureConfigDir();
+  const tmpPath = `${PREFERENCES_FILE}.tmp`;
+  fs.writeFileSync(tmpPath, content, 'utf8');
+  fs.renameSync(tmpPath, PREFERENCES_FILE);
+  return content;
+}
+
+function loadPreferences() {
+  ensureConfigDir();
+  if (!fs.existsSync(PREFERENCES_FILE)) {
+    const template = readTemplate();
+    savePreferences(template);
+    return template;
+  }
+
+  const content = fs.readFileSync(PREFERENCES_FILE, 'utf8');
+  const validation = validatePreferences(content);
+  if (!validation.valid) {
+    throw new Error(validation.error);
+  }
+  return content;
+}
+
+function resetPreferences() {
+  const template = readTemplate();
+  return savePreferences(template);
+}
+
+function parseSectionTarget(section) {
+  const trimmed = section.trim();
+  if (!trimmed) {
+    throw new Error('Section name is required');
+  }
+
+  const match = trimmed.match(/^(#{1,6})\s*(.+)$/);
+  if (match) {
+    return { level: match[1].length, name: match[2].trim() };
+  }
+
+  return { level: null, name: trimmed };
+}
+
+function findSection(lines, target) {
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = lines[i].match(/^(#{1,6})\s*(.+?)\s*$/);
+    if (!match) {
+      continue;
+    }
+    const level = match[1].length;
+    const name = match[2].trim();
+
+    if (target.level && level !== target.level) {
+      continue;
+    }
+
+    if (name.toLowerCase() === target.name.toLowerCase()) {
+      return { index: i, level };
+    }
+  }
+  return null;
+}
+
+function appendToSection(section, text) {
+  if (typeof text !== 'string' || !text.trim()) {
+    throw new Error('Append text is required');
+  }
+
+  const target = parseSectionTarget(section);
+  const content = loadPreferences();
+  const lines = content.split(/\r?\n/);
+  const match = findSection(lines, target);
+  const trimmedText = text.replace(/\s+$/, '');
+
+  if (!match) {
+    const headingLevel = target.level || 2;
+    const headingLine = `${'#'.repeat(headingLevel)} ${target.name}`;
+    const newLines = [...lines];
+
+    if (newLines.length > 0 && newLines[newLines.length - 1].trim() !== '') {
+      newLines.push('');
+    }
+    newLines.push(headingLine, '');
+    newLines.push(...trimmedText.split(/\r?\n/));
+
+    return savePreferences(newLines.join('\n'));
+  }
+
+  let insertIndex = lines.length;
+  for (let i = match.index + 1; i < lines.length; i += 1) {
+    const headingMatch = lines[i].match(/^(#{1,6})\s*(.+?)\s*$/);
+    if (!headingMatch) {
+      continue;
+    }
+    const level = headingMatch[1].length;
+    if (level <= match.level) {
+      insertIndex = i;
+      break;
+    }
+  }
+
+  const insertLines = trimmedText.split(/\r?\n/);
+  const lineBefore = lines[insertIndex - 1];
+  if (lineBefore !== undefined && lineBefore.trim() !== '') {
+    insertLines.unshift('');
+  }
+
+  const updated = [...lines];
+  updated.splice(insertIndex, 0, ...insertLines);
+
+  return savePreferences(updated.join('\n'));
+}
+
+module.exports = {
+  getPreferencesPath,
+  loadPreferences,
+  savePreferences,
+  appendToSection,
+  resetPreferences,
+  validatePreferences,
+  PREFERENCES_FILE,
+  TEMPLATE_PATH
+};

package/src/skill-installer.js

@@ -0,0 +1,175 @@
+/**
+ * skill-installer.js - Install/uninstall Claude Code skill
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const SKILL_NAME = 'synap-assistant';
+const SKILL_SOURCE = 'synap-cli';
+const SOURCE_SKILL_DIR = path.join(__dirname, '..', '.claude', 'skills', SKILL_NAME);
+const TARGET_SKILL_DIR = path.join(os.homedir(), '.claude', 'skills', SKILL_NAME);
+const SOURCE_SKILL_FILE = path.join(SOURCE_SKILL_DIR, 'SKILL.md');
+const TARGET_SKILL_FILE = path.join(TARGET_SKILL_DIR, 'SKILL.md');
+
+/**
+ * Get MD5 hash of content
+ */
+function getHash(content) {
+  return crypto.createHash('md5').update(content).digest('hex');
+}
+
+function extractFrontMatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!match) {
+    return { frontMatter: null, body: content };
+  }
+  return { frontMatter: match[1], body: content.slice(match[0].length) };
+}
+
+function parseFrontMatter(frontMatter) {
+  const data = {};
+  if (!frontMatter) {
+    return data;
+  }
+  const lines = frontMatter.split('\n');
+  for (const line of lines) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (match) {
+      data[match[1]] = match[2].trim();
+    }
+  }
+  return data;
+}
+
+function applyFrontMatterUpdates(content, updates) {
+  const { frontMatter, body } = extractFrontMatter(content);
+  const lines = frontMatter ? frontMatter.split('\n') : [];
+  const updatedLines = [];
+  const handled = new Set();
+
+  for (const line of lines) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (match && Object.prototype.hasOwnProperty.call(updates, match[1])) {
+      const key = match[1];
+      const value = updates[key];
+      handled.add(key);
+      if (value === null || value === undefined) {
+        continue;
+      }
+      updatedLines.push(`${key}: ${value}`);
+    } else {
+      updatedLines.push(line);
+    }
+  }
+
+  for (const [key, value] of Object.entries(updates)) {
+    if (handled.has(key)) {
+      continue;
+    }
+    if (value === null || value === undefined) {
+      continue;
+    }
+    updatedLines.push(`${key}: ${value}`);
+  }
+
+  const front = `---\n${updatedLines.join('\n')}\n---\n`;
+  return front + body;
+}
+
+function getCanonicalContent(content) {
+  return applyFrontMatterUpdates(content, { source: SKILL_SOURCE, hash: null });
+}
+
+function buildSkillContent(content) {
+  const canonical = getCanonicalContent(content);
+  const hash = getHash(canonical);
+  const withHash = applyFrontMatterUpdates(canonical, { source: SKILL_SOURCE, hash });
+  return { canonical, hash, content: withHash };
+}
+
+function extractMetadata(content) {
+  const { frontMatter } = extractFrontMatter(content);
+  const data = parseFrontMatter(frontMatter);
+  return {
+    source: data.source || null,
+    hash: data.hash || null
+  };
+}
+
+/**
+ * Install the skill
+ */
+async function install(options = {}) {
+  // Check if source skill exists
+  if (!fs.existsSync(SOURCE_SKILL_FILE)) {
+    throw new Error(`Source skill not found: ${SOURCE_SKILL_FILE}`);
+  }
+
+  const sourceContent = fs.readFileSync(SOURCE_SKILL_FILE, 'utf8');
+  const { content: normalizedSourceContent, hash: sourceHash } = buildSkillContent(sourceContent);
+
+  // Ensure target directory exists
+  if (!fs.existsSync(TARGET_SKILL_DIR)) {
+    fs.mkdirSync(TARGET_SKILL_DIR, { recursive: true });
+  }
+
+  // Check if target exists
+  if (fs.existsSync(TARGET_SKILL_FILE)) {
+    const targetContent = fs.readFileSync(TARGET_SKILL_FILE, 'utf8');
+    const { source: targetSource, hash: targetHash } = extractMetadata(targetContent);
+    const canonicalTarget = getCanonicalContent(targetContent);
+    const canonicalTargetHash = getHash(canonicalTarget);
+    const targetMatchesSource = canonicalTargetHash === sourceHash;
+
+    if (targetSource !== SKILL_SOURCE && !options.force) {
+      return { installed: false, needsForce: true };
+    }
+
+    if (targetSource === SKILL_SOURCE && !options.force) {
+      if (targetMatchesSource && targetContent === normalizedSourceContent) {
+        return { installed: false, skipped: true };
+      }
+
+      if (targetHash) {
+        if (targetHash !== canonicalTargetHash) {
+          return { installed: false, needsForce: true };
+        }
+      } else if (!targetMatchesSource) {
+        return { installed: false, needsForce: true };
+      }
+    }
+
+    const backupFile = TARGET_SKILL_FILE + '.backup';
+    fs.writeFileSync(backupFile, targetContent);
+  }
+
+  // Install
+  fs.writeFileSync(TARGET_SKILL_FILE, normalizedSourceContent);
+
+  return { installed: true };
+}
+
+/**
+ * Uninstall the skill
+ */
+async function uninstall() {
+  if (fs.existsSync(TARGET_SKILL_FILE)) {
+    fs.unlinkSync(TARGET_SKILL_FILE);
+  }
+  if (fs.existsSync(TARGET_SKILL_DIR)) {
+    try {
+      fs.rmdirSync(TARGET_SKILL_DIR);
+    } catch {
+      // Directory not empty, that's ok
+    }
+  }
+  return { uninstalled: true };
+}
+
+module.exports = {
+  install,
+  uninstall
+};