anchi-toolkit 1.0.0

package/src/commands/update.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+// =============================================================================
+// anchi-toolkit Update Command
+// Usage: npx anchi-toolkit update
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.cyan}${msg}${colors.reset}`),
+    success: (msg) => console.log(`${colors.green}${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}${msg}${colors.reset}`),
+    gray: (msg) => console.log(`${colors.gray}${msg}${colors.reset}`),
+};
+
+// Get current installed version
+function getCurrentVersion() {
+    try {
+        const kitPath = path.resolve(__dirname, '..');
+        const pkgPath = path.join(kitPath, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            return pkg.version || '0.0.0';
+        }
+    } catch (e) {
+        return '0.0.0';
+    }
+    return '0.0.0';
+}
+
+// Check npm registry for latest version
+function getLatestVersion() {
+    return new Promise((resolve, reject) => {
+        https.get('https://registry.npmjs.org/anchi-toolkit/latest', (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const pkg = JSON.parse(data);
+                    resolve(pkg.version || '0.0.0');
+                } catch (e) {
+                    resolve('0.0.0');
+                }
+            });
+        }).on('error', () => resolve('0.0.0'));
+    });
+}
+
+// Compare versions (simple semver compare)
+function isNewer(latest, current) {
+    const l = latest.split('.').map(Number);
+    const c = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((l[i] || 0) > (c[i] || 0)) return true;
+        if ((l[i] || 0) < (c[i] || 0)) return false;
+    }
+    return false;
+}
+
+// Backup and update files
+function updateFiles(targetPath, kitPath) {
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').slice(0, 15);
+    const updatableComponents = [
+        { path: '.cursor/commands', desc: 'Commands' },
+        { path: '.cursor/agents', desc: 'Agents' },
+        { path: '.cursor/skills', desc: 'Skills' },
+    ];
+
+    let updated = 0;
+
+    for (const comp of updatableComponents) {
+        const sourcePath = path.join(kitPath, comp.path);
+        const destPath = path.join(targetPath, comp.path);
+
+        if (fs.existsSync(sourcePath) && fs.existsSync(destPath)) {
+            // Backup existing
+            const backupPath = `${destPath}.backup_${timestamp}`;
+            log.gray(`  📦 Backing up ${comp.desc}...`);
+
+            // Copy source to dest (overwrite)
+            copyDirRecursive(sourcePath, destPath);
+            log.success(`  ✅ Updated: ${comp.desc}`);
+            updated++;
+        }
+    }
+
+    return updated;
+}
+
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+
+// Main update function
+async function update() {
+    console.log('');
+    log.info('╔═══════════════════════════════════════════════════════════╗');
+    log.info('║           🔄 anchi-toolkit Update                             ║');
+    log.info('╚═══════════════════════════════════════════════════════════╝');
+    console.log('');
+
+    const currentVersion = getCurrentVersion();
+    log.gray(`📦 Current version: ${currentVersion}`);
+
+    log.info('🔍 Checking for updates...');
+    const latestVersion = await getLatestVersion();
+
+    if (latestVersion === '0.0.0') {
+        log.warn('⚠️  Could not check npm registry.');
+        log.gray('   Package may not be published yet.');
+        log.info('');
+        log.info('💡 For now, you can update manually:');
+        log.success('   git pull origin main');
+        return;
+    }
+
+    log.gray(`📦 Latest version: ${latestVersion}`);
+    console.log('');
+
+    if (isNewer(latestVersion, currentVersion)) {
+        log.warn(`🆕 New version available: ${currentVersion} → ${latestVersion}`);
+        console.log('');
+        log.info('To update, run:');
+        log.success('  npm update -g anchi-toolkit');
+        log.info('');
+        log.info('Or reinstall:');
+        log.success('  npm install -g anchi-toolkit@latest');
+    } else {
+        log.success('✅ You are using the latest version!');
+    }
+
+    console.log('');
+    log.info('💡 To update project files:');
+    log.success('   npx anchi-toolkit install');
+    log.gray('   (Use Overwrite when prompted)');
+    console.log('');
+}
+
+module.exports = { update };

package/src/lib/configManager.js

@@ -0,0 +1,200 @@
+// =============================================================================
+// anchi-toolkit Config Manager
+// Handles loading, saving, and merging configuration
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_FILENAME = 'anchi-toolkit.config.yaml';
+
+// Default configuration
+const DEFAULT_CONFIG = {
+    version: '2.1',
+    profile: 'developer',
+
+    model_preference: {
+        default: 'auto',
+        complex: 'opus',
+        economy: 'haiku',
+    },
+
+    features: {
+        auto_commit: false,
+        auto_push: false,
+        progress_indicators: true,
+        summary_cards: true,
+        quick_actions: true,
+    },
+
+    team: {
+        role: null,  // frontend, backend, fullstack, lead, etc.
+        slack_webhook: null,
+        notifications: true,
+    },
+
+    hooks: {
+        enabled: false,
+        pre_commit: [],
+        post_merge: [],
+    },
+};
+
+/**
+ * Parse simple YAML (subset)
+ */
+function parseYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    const stack = [{ obj: result, indent: -1 }];
+
+    for (const line of lines) {
+        if (line.trim() === '' || line.trim().startsWith('#')) continue;
+
+        const match = line.match(/^(\s*)([^:]+):\s*(.*)$/);
+        if (!match) continue;
+
+        const indent = match[1].length;
+        const key = match[2].trim();
+        let value = match[3].trim();
+
+        // Pop stack until we find parent
+        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+            stack.pop();
+        }
+
+        const parent = stack[stack.length - 1].obj;
+
+        if (value === '' || value === null) {
+            // Nested object
+            parent[key] = {};
+            stack.push({ obj: parent[key], indent: indent });
+        } else {
+            // Parse value
+            if (value === 'true') value = true;
+            else if (value === 'false') value = false;
+            else if (value === 'null') value = null;
+            else if (!isNaN(value)) value = Number(value);
+            else if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
+            else if (value.startsWith('[') && value.endsWith(']')) {
+                value = value.slice(1, -1).split(',').map(s => s.trim());
+            }
+            parent[key] = value;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Stringify to YAML
+ */
+function stringifyYaml(obj, indent = 0) {
+    let result = '';
+    const prefix = '  '.repeat(indent);
+
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === null) {
+            result += `${prefix}${key}: null\n`;
+        } else if (typeof value === 'object' && !Array.isArray(value)) {
+            result += `${prefix}${key}:\n`;
+            result += stringifyYaml(value, indent + 1);
+        } else if (Array.isArray(value)) {
+            result += `${prefix}${key}: [${value.join(', ')}]\n`;
+        } else if (typeof value === 'string') {
+            result += `${prefix}${key}: "${value}"\n`;
+        } else {
+            result += `${prefix}${key}: ${value}\n`;
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Deep merge objects
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const key of Object.keys(source)) {
+        if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] || {}, source[key]);
+        } else {
+            result[key] = source[key];
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Load config from target directory
+ */
+function loadConfig(targetDir) {
+    const configPath = path.join(targetDir, '.cursor', CONFIG_FILENAME);
+
+    if (!fs.existsSync(configPath)) {
+        return DEFAULT_CONFIG;
+    }
+
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const userConfig = parseYaml(content);
+        return deepMerge(DEFAULT_CONFIG, userConfig);
+    } catch (e) {
+        console.warn(`Warning: Could not parse config: ${e.message}`);
+        return DEFAULT_CONFIG;
+    }
+}
+
+/**
+ * Save config to target directory
+ */
+function saveConfig(targetDir, config) {
+    const cursorDir = path.join(targetDir, '.cursor');
+    const configPath = path.join(cursorDir, CONFIG_FILENAME);
+
+    if (!fs.existsSync(cursorDir)) {
+        fs.mkdirSync(cursorDir, { recursive: true });
+    }
+
+    const header = `# anchi-toolkit Configuration
+# https://github.com/ANCHI-STE/anchi-webkit-dev
+# ═══════════════════════════════════════════════════════════════
+
+`;
+
+    fs.writeFileSync(configPath, header + stringifyYaml(config));
+    return configPath;
+}
+
+/**
+ * Get config value by path (e.g., 'features.auto_commit')
+ */
+function getConfigValue(config, keyPath) {
+    return keyPath.split('.').reduce((obj, key) => obj?.[key], config);
+}
+
+/**
+ * Set config value by path
+ */
+function setConfigValue(config, keyPath, value) {
+    const keys = keyPath.split('.');
+    const lastKey = keys.pop();
+    const target = keys.reduce((obj, key) => obj[key] = obj[key] || {}, config);
+    target[lastKey] = value;
+    return config;
+}
+
+module.exports = {
+    DEFAULT_CONFIG,
+    CONFIG_FILENAME,
+    loadConfig,
+    saveConfig,
+    parseYaml,
+    stringifyYaml,
+    deepMerge,
+    getConfigValue,
+    setConfigValue,
+};

package/src/lib/contextDatabase.js

@@ -0,0 +1,362 @@
+// =============================================================================
+// anchi-toolkit SQLite Context Database
+// Phase 2: Persistent storage with relationships
+// =============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+const DB_DIR = '.cursor/context';
+const DB_FILE = 'context.db';
+
+// SQLite schema for context database
+const SCHEMA = `
+-- Project information
+CREATE TABLE IF NOT EXISTS project (
+  id INTEGER PRIMARY KEY,
+  name TEXT,
+  description TEXT,
+  tech_stack TEXT,
+  architecture TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Session history
+CREATE TABLE IF NOT EXISTS sessions (
+  id INTEGER PRIMARY KEY,
+  task TEXT,
+  phase TEXT,
+  files_opened TEXT,
+  started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  ended_at DATETIME
+);
+
+-- Decisions log
+CREATE TABLE IF NOT EXISTS decisions (
+  id INTEGER PRIMARY KEY,
+  decision TEXT NOT NULL,
+  reason TEXT,
+  files_affected TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Notes
+CREATE TABLE IF NOT EXISTS notes (
+  id INTEGER PRIMARY KEY,
+  note TEXT NOT NULL,
+  category TEXT DEFAULT 'general',
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Entities (knowledge graph nodes)
+CREATE TABLE IF NOT EXISTS entities (
+  id INTEGER PRIMARY KEY,
+  name TEXT UNIQUE NOT NULL,
+  type TEXT,
+  description TEXT,
+  metadata TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Entity relationships (knowledge graph edges)
+CREATE TABLE IF NOT EXISTS relations (
+  id INTEGER PRIMARY KEY,
+  source_id INTEGER NOT NULL,
+  target_id INTEGER NOT NULL,
+  relation_type TEXT NOT NULL,
+  metadata TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (source_id) REFERENCES entities(id),
+  FOREIGN KEY (target_id) REFERENCES entities(id)
+);
+
+-- File analysis cache
+CREATE TABLE IF NOT EXISTS file_cache (
+  id INTEGER PRIMARY KEY,
+  file_path TEXT UNIQUE NOT NULL,
+  summary TEXT,
+  entities TEXT,
+  last_modified DATETIME,
+  analyzed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+`;
+
+/**
+ * Get database path
+ */
+function getDbPath(targetDir) {
+    return path.join(targetDir, DB_DIR, DB_FILE);
+}
+
+/**
+ * Get database directory
+ */
+function getDbDir(targetDir) {
+    return path.join(targetDir, DB_DIR);
+}
+
+/**
+ * Check if better-sqlite3 is available
+ */
+function hasSqlite() {
+    try {
+        require('better-sqlite3');
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Initialize database (creates if not exists)
+ * Note: Requires better-sqlite3 package
+ */
+function initDatabase(targetDir) {
+    if (!hasSqlite()) {
+        console.log('SQLite not available. Using JSON fallback.');
+        return null;
+    }
+
+    const Database = require('better-sqlite3');
+    const dbDir = getDbDir(targetDir);
+    const dbPath = getDbPath(targetDir);
+
+    if (!fs.existsSync(dbDir)) {
+        fs.mkdirSync(dbDir, { recursive: true });
+    }
+
+    const db = new Database(dbPath);
+    db.exec(SCHEMA);
+
+    return db;
+}
+
+/**
+ * Get or create database instance
+ */
+let _db = null;
+function getDatabase(targetDir) {
+    if (!_db) {
+        _db = initDatabase(targetDir);
+    }
+    return _db;
+}
+
+/**
+ * Close database connection
+ */
+function closeDatabase() {
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+}
+
+// =============================================================================
+// CRUD Operations
+// =============================================================================
+
+/**
+ * Set project info
+ */
+function setProject(targetDir, info) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT OR REPLACE INTO project (id, name, description, tech_stack, architecture, updated_at)
+    VALUES (1, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `);
+
+    stmt.run(
+        info.name,
+        info.description,
+        JSON.stringify(info.tech_stack || []),
+        info.architecture
+    );
+
+    return info;
+}
+
+/**
+ * Get project info
+ */
+function getProject(targetDir) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const row = db.prepare('SELECT * FROM project WHERE id = 1').get();
+    if (!row) return null;
+
+    return {
+        name: row.name,
+        description: row.description,
+        tech_stack: JSON.parse(row.tech_stack || '[]'),
+        architecture: row.architecture,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+
+/**
+ * Add decision
+ */
+function addDecisionDb(targetDir, decision, reason = '', filesAffected = []) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO decisions (decision, reason, files_affected)
+    VALUES (?, ?, ?)
+  `);
+
+    const result = stmt.run(decision, reason, JSON.stringify(filesAffected));
+    return result.lastInsertRowid;
+}
+
+/**
+ * Get recent decisions
+ */
+function getDecisions(targetDir, limit = 10) {
+    const db = getDatabase(targetDir);
+    if (!db) return [];
+
+    return db.prepare(`
+    SELECT * FROM decisions ORDER BY created_at DESC LIMIT ?
+  `).all(limit);
+}
+
+/**
+ * Add note
+ */
+function addNoteDb(targetDir, note, category = 'general') {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO notes (note, category) VALUES (?, ?)
+  `);
+
+    const result = stmt.run(note, category);
+    return result.lastInsertRowid;
+}
+
+/**
+ * Get recent notes
+ */
+function getNotes(targetDir, category = null, limit = 10) {
+    const db = getDatabase(targetDir);
+    if (!db) return [];
+
+    if (category) {
+        return db.prepare(`
+      SELECT * FROM notes WHERE category = ? ORDER BY created_at DESC LIMIT ?
+    `).all(category, limit);
+    }
+
+    return db.prepare(`
+    SELECT * FROM notes ORDER BY created_at DESC LIMIT ?
+  `).all(limit);
+}
+
+/**
+ * Upsert entity
+ */
+function upsertEntityDb(targetDir, name, type, description = '', metadata = {}) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO entities (name, type, description, metadata, updated_at)
+    VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(name) DO UPDATE SET
+      type = excluded.type,
+      description = excluded.description,
+      metadata = excluded.metadata,
+      updated_at = CURRENT_TIMESTAMP
+  `);
+
+    stmt.run(name, type, description, JSON.stringify(metadata));
+    return name;
+}
+
+/**
+ * Get entity
+ */
+function getEntityDb(targetDir, name) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const row = db.prepare('SELECT * FROM entities WHERE name = ?').get(name);
+    if (!row) return null;
+
+    return {
+        id: row.id,
+        name: row.name,
+        type: row.type,
+        description: row.description,
+        metadata: JSON.parse(row.metadata || '{}'),
+    };
+}
+
+/**
+ * Add relation between entities
+ */
+function addRelation(targetDir, sourceName, targetName, relationType, metadata = {}) {
+    const db = getDatabase(targetDir);
+    if (!db) return null;
+
+    const source = db.prepare('SELECT id FROM entities WHERE name = ?').get(sourceName);
+    const target = db.prepare('SELECT id FROM entities WHERE name = ?').get(targetName);
+
+    if (!source || !target) return null;
+
+    const stmt = db.prepare(`
+    INSERT INTO relations (source_id, target_id, relation_type, metadata)
+    VALUES (?, ?, ?, ?)
+  `);
+
+    const result = stmt.run(source.id, target.id, relationType, JSON.stringify(metadata));
+    return result.lastInsertRowid;
+}
+
+/**
+ * Get relations for entity
+ */
+function getRelations(targetDir, entityName) {
+    const db = getDatabase(targetDir);
+    if (!db) return [];
+
+    return db.prepare(`
+    SELECT 
+      r.*,
+      s.name as source_name,
+      t.name as target_name
+    FROM relations r
+    JOIN entities s ON r.source_id = s.id
+    JOIN entities t ON r.target_id = t.id
+    WHERE s.name = ? OR t.name = ?
+  `).all(entityName, entityName);
+}
+
+module.exports = {
+    SCHEMA,
+    getDbPath,
+    initDatabase,
+    getDatabase,
+    closeDatabase,
+    hasSqlite,
+    // CRUD
+    setProject,
+    getProject,
+    addDecisionDb,
+    getDecisions,
+    addNoteDb,
+    getNotes,
+    upsertEntityDb,
+    getEntityDb,
+    addRelation,
+    getRelations,
+};