@relipa/ai-flow-kit 0.1.6 → 0.1.7

package/scripts/memory.js

@@ -1,247 +1,176 @@
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-
-const MEMORY_DIR = path.join(process.cwd(), '.aiflow', 'memory');
-
-async function ensureMemoryDir() {
-    await fs.ensureDir(MEMORY_DIR);
-}
-
-/**
- * Save knowledge to memory
- */
-async function saveMemory(key, value, metadata = {}) {
-    await ensureMemoryDir();
-
-    const fileName = `${sanitizeFileName(key)}.json`;
-    const filePath = path.join(MEMORY_DIR, fileName);
-
-    const memory = {
-        key,
-        value,
-        metadata: {
-            created: new Date().toISOString(),
-            updated: new Date().toISOString(),
-            ...metadata
-        }
-    };
-
-    await fs.writeJson(filePath, memory, { spaces: 2 });
-    console.log(chalk.green(`✓ Saved: ${key}`));
-
-    return memory;
-}
-
-/**
- * Get memory by key
- */
-async function getMemory(key) {
-    await ensureMemoryDir();
-
-    const fileName = `${sanitizeFileName(key)}.json`;
-    const filePath = path.join(MEMORY_DIR, fileName);
-
-    if (!(await fs.pathExists(filePath))) {
-        return null;
-    }
-
-    return await fs.readJson(filePath);
-}
-
-/**
- * List all memories
- */
-async function listMemories() {
-    await ensureMemoryDir();
-
-    const files = await fs.readdir(MEMORY_DIR);
-    const memories = [];
-
-    for (const file of files) {
-        if (file.endsWith('.json')) {
-            const memory = await fs.readJson(path.join(MEMORY_DIR, file));
-            memories.push({
-                key: memory.key,
-                value: memory.value.substring(0, 100) + (memory.value.length > 100 ? '...' : ''),
-                created: memory.metadata.created,
-                updated: memory.metadata.updated
-            });
-        }
-    }
-
-    return memories.sort((a, b) => new Date(b.created) - new Date(a.created));
-}
-
-/**
- * Search memories by keyword
- */
-async function searchMemories(query) {
-    await ensureMemoryDir();
-
-    const files = await fs.readdir(MEMORY_DIR);
-    const results = [];
-
-    for (const file of files) {
-        if (file.endsWith('.json')) {
-            const memory = await fs.readJson(path.join(MEMORY_DIR, file));
-            const matchesKey = memory.key.toLowerCase().includes(query.toLowerCase());
-            const matchesValue = memory.value.toLowerCase().includes(query.toLowerCase());
-
-            if (matchesKey || matchesValue) {
-                results.push({
-                    key: memory.key,
-                    value: memory.value.substring(0, 150) + (memory.value.length > 150 ? '...' : ''),
-                    matches: matchesKey ? ['key'] : [],
-                    created: memory.metadata.created
-                });
-            }
-        }
-    }
-
-    return results;
-}
-
-/**
- * Delete memory
- */
-async function deleteMemory(key) {
-    await ensureMemoryDir();
-
-    const fileName = `${sanitizeFileName(key)}.json`;
-    const filePath = path.join(MEMORY_DIR, fileName);
-
-    if (!(await fs.pathExists(filePath))) {
-        console.log(chalk.yellow(`! Memory not found: ${key}`));
-        return false;
-    }
-
-    await fs.remove(filePath);
-    console.log(chalk.green(`✓ Deleted: ${key}`));
-    return true;
-}
-
-/**
- * Clear all memories
- */
-async function clearAllMemories() {
-    await fs.emptyDir(MEMORY_DIR);
-    console.log(chalk.green(`✓ Cleared all memories`));
-}
-
-/**
- * Auto-load relevant memories for current context
- */
-async function loadRelevantMemories(contextDescription) {
-    const keywords = contextDescription.split(/\s+/).filter(w => w.length > 3);
-    const allMemories = await listMemories();
-    const relevant = [];
-
-    for (const memory of allMemories) {
-        const score = keywords.filter(k =>
-            memory.key.toLowerCase().includes(k.toLowerCase()) ||
-            memory.value.toLowerCase().includes(k.toLowerCase())
-        ).length;
-
-        if (score > 0) {
-            const fullMemory = await getMemory(memory.key);
-            relevant.push({
-                ...memory,
-                score,
-                content: fullMemory.value
-            });
-        }
-    }
-
-    return relevant.sort((a, b) => b.score - a.score);
-}
-
-/**
- * Display memory in CLI
- */
-async function displayMemory(memory) {
-    console.log(chalk.cyan(`\n📝 ${memory.key}`));
-    console.log(chalk.gray(`Created: ${new Date(memory.metadata.created).toLocaleDateString()}`));
-    console.log(chalk.gray(`Updated: ${new Date(memory.metadata.updated).toLocaleDateString()}`));
-    console.log(chalk.white(`\n${memory.value}\n`));
-}
-
-/**
- * Sanitize file name from key
- */
-function sanitizeFileName(key) {
-    return key
-        .toLowerCase()
-        .replace(/[^\w\s-]/g, '')
-        .replace(/\s+/g, '-')
-        .replace(/-+/g, '-')
-        .substring(0, 50);
-}
-
-module.exports = async function memory(command, args = {}) {
-    try {
-        if (command === 'save' && args.key && args.value) {
-            return await saveMemory(args.key, args.value, args.metadata);
-        }
-
-        if (command === 'get' && args.key) {
-            const m = await getMemory(args.key);
-            if (m) {
-                await displayMemory(m);
-                return m;
-            } else {
-                console.log(chalk.yellow(`! Memory not found: ${args.key}`));
-            }
-        }
-
-        if (command === 'list') {
-            const memories = await listMemories();
-            if (memories.length === 0) {
-                console.log(chalk.gray('No memories saved yet'));
-                return;
-            }
-            console.log(chalk.cyan('\n📚 Saved Memories:\n'));
-            memories.forEach((m, i) => {
-                console.log(`${i + 1}. ${chalk.white(m.key)}`);
-                console.log(`   ${chalk.gray(m.value)}`);
-                console.log(`   ${chalk.gray('Created: ' + new Date(m.created).toLocaleDateString())}\n`);
-            });
-        }
-
-        if (command === 'search' && args.query) {
-            const results = await searchMemories(args.query);
-            if (results.length === 0) {
-                console.log(chalk.gray(`No memories matching "${args.query}"`));
-                return;
-            }
-            console.log(chalk.cyan(`\n🔍 Found ${results.length} memories matching "${args.query}":\n`));
-            results.forEach((m, i) => {
-                console.log(`${i + 1}. ${chalk.white(m.key)}`);
-                console.log(`   ${chalk.gray(m.value)}\n`);
-            });
-        }
-
-        if (command === 'delete' && args.key) {
-            return await deleteMemory(args.key);
-        }
-
-        if (command === 'clear') {
-            return await clearAllMemories();
-        }
-
-        if (command === 'auto-load' && args.context) {
-            return await loadRelevantMemories(args.context);
-        }
-
-    } catch (err) {
-        console.error(chalk.red(`Error: ${err.message}`));
-    }
-};
-
-module.exports.saveMemory = saveMemory;
-module.exports.getMemory = getMemory;
-module.exports.listMemories = listMemories;
-module.exports.searchMemories = searchMemories;
-module.exports.deleteMemory = deleteMemory;
-module.exports.clearAllMemories = clearAllMemories;
-module.exports.loadRelevantMemories = loadRelevantMemories;
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const store = require('./memory-store');
+const docsBranchCommand = require('./docs-branch');
+
+// CLI for the "99.Memory/" Project Brain (docs/internal/Memory-Architecture-v1.0.md).
+// Thin dispatch layer: business logic lives in memory-store.js, git/MR logic is reused
+// from docs-branch.js (same "AI drafts — human approves via MR" pattern as `ak docs`).
+//
+// Replaces the legacy JSON key/value store this file used to implement
+// (`.aiflow/memory/*.json`, save/get/search/delete/clear) — unrelated to 99.Memory/,
+// retired outright (no backward-compat shim; nothing in the kit still reads that store).
+
+const PROJECT_DIR = process.cwd();
+
+module.exports = async function memory(action, options = {}) {
+    try {
+        if (action === 'draft')  return await draftCmd(options);
+        if (action === 'list')   return await listCmd(options);
+        if (action === 'submit') return await submitCmd(options);
+        if (action === 'remove') return await removeCmd(options);
+
+        console.log(chalk.yellow('Usage:'));
+        console.log(chalk.gray('  ak memory draft --category <cat> --slug <slug> --content <text> [options]'));
+        console.log(chalk.gray('  ak memory list [--approved]'));
+        console.log(chalk.gray('  ak memory submit <pendingPath> --title "..." [--yes]'));
+        console.log(chalk.gray('  ak memory remove <path> [--hard] [--reason "..."] --title "..." [--yes]'));
+        console.log(chalk.gray(`\n  Categories: ${Object.keys(store.CATEGORIES).join(', ')}`));
+    } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exitCode = 1;
+    }
+};
+
+async function draftCmd(options) {
+    if (!options.category || !options.slug || !options.content) {
+        console.log(chalk.red('✗ Cần --category, --slug, và --content.'));
+        process.exitCode = 1;
+        return;
+    }
+    const tags = splitList(options.tags);
+    const workflows = splitList(options.workflows, ['all']);
+
+    const result = await store.createDraft(PROJECT_DIR, {
+        category: options.category,
+        functionId: options.functionId,
+        scope: options.scope,
+        slug: options.slug,
+        content: options.content,
+        source: options.source || '',
+        tags, workflows,
+        confidence: options.confidence !== undefined ? Number(options.confidence) : 0.5,
+    });
+
+    if (result.conflict) {
+        console.log(chalk.yellow(`⚠ Memory tương tự đã có tại: ${result.existingPath}`));
+        console.log(chalk.gray('  Sửa file đó trực tiếp nếu muốn cập nhật, thay vì tạo bản mới.'));
+        return result;
+    }
+
+    console.log(chalk.green(`✓ Draft đã tạo: ${result.path}`));
+    console.log(chalk.gray(`  id: ${result.id} (local — chỉ máy này recall được cho tới khi submit)`));
+    return result;
+}
+
+async function listCmd(options) {
+    const memories = options.approved
+        ? await store.listApproved(PROJECT_DIR)
+        : await store.listDrafts(PROJECT_DIR);
+
+    if (memories.length === 0) {
+        console.log(chalk.gray(options.approved ? 'Chưa có memory nào được approve.' : 'Chưa có draft nào trong _pending/.'));
+        return memories;
+    }
+
+    console.log(chalk.cyan(`\n${options.approved ? 'Approved memories' : 'Pending drafts (local)'}:\n`));
+    for (const m of memories) {
+        console.log(`  ${chalk.white(m.id || '(no id)')}  ${chalk.gray(m.relPath)}`);
+        console.log(`    ${chalk.gray(`type=${m.type} scope=${m.scope} workflows=${m.workflows}`)}`);
+    }
+    console.log();
+    return memories;
+}
+
+/**
+ * Submit a pending draft: create a branch in AK-Docs, move the file from _pending/
+ * to its destination path, commit, push, open an MR — same two-step CLI already
+ * used by `ak docs branch` + `ak docs submit --yes` (custom/templates/shared/*.md).
+ */
+async function submitCmd(options) {
+    const pendingRelPath = options._positional && options._positional[0];
+    if (!pendingRelPath || !options.title) {
+        console.log(chalk.red('✗ Cần <pendingPath> (từ `ak memory list`) và --title.'));
+        process.exitCode = 1;
+        return;
+    }
+
+    const base = store.memoryDir(PROJECT_DIR);
+    const pendingAbs = path.join(base, pendingRelPath);
+    if (!(await fs.pathExists(pendingAbs))) {
+        console.log(chalk.red(`✗ Không tìm thấy draft: ${pendingRelPath}`));
+        process.exitCode = 1;
+        return;
+    }
+
+    const { data } = store.parseFrontmatter(await fs.readFile(pendingAbs, 'utf-8'));
+    const destRelPath = pendingRelPath.replace(/^_pending[\\/]/, '');
+    const destAbs = path.join(base, destRelPath);
+
+    const slug = path.basename(destRelPath, '.md');
+    const branchResult = await docsBranchCommand.createBranch({
+        functionId: 'memory', taskId: slug, repo: 'AK-Docs', yes: options.yes,
+    });
+    if (!branchResult) return; // createBranch already printed the reason / plan
+
+    await fs.ensureDir(path.dirname(destAbs));
+    await fs.move(pendingAbs, destAbs, { overwrite: false });
+
+    return docsBranchCommand.submitDocs({
+        title: options.title,
+        description: options.description || `Memory: ${data.id || slug}`,
+        repo: 'AK-Docs', yes: options.yes,
+    });
+}
+
+/**
+ * Propose removal (Luồng 4): same branch+MR mechanism as submit, but moves the
+ * target file into _deprecated/ (soft, default) or deletes it outright (--hard).
+ */
+async function removeCmd(options) {
+    const targetRelPath = options._positional && options._positional[0];
+    if (!targetRelPath || !options.title) {
+        console.log(chalk.red('✗ Cần <path đã approve> (từ `ak memory list --approved`) và --title.'));
+        process.exitCode = 1;
+        return;
+    }
+
+    const base = store.memoryDir(PROJECT_DIR);
+    const targetAbs = path.join(base, targetRelPath);
+    if (!(await fs.pathExists(targetAbs))) {
+        console.log(chalk.red(`✗ Không tìm thấy memory: ${targetRelPath}`));
+        process.exitCode = 1;
+        return;
+    }
+
+    const slug = path.basename(targetRelPath, '.md');
+    const branchResult = await docsBranchCommand.createBranch({
+        functionId: 'memory', taskId: `remove-${slug}`, repo: 'AK-Docs', yes: options.yes,
+    });
+    if (!branchResult) return;
+
+    if (options.hard) {
+        await fs.remove(targetAbs);
+        console.log(chalk.yellow(`⚠ Hard-remove: đã xóa file khỏi working tree. Lý do: ${options.reason || '(không ghi lý do)'}`));
+    } else {
+        const deprecatedAbs = path.join(base, '_deprecated', path.basename(targetRelPath));
+        await fs.ensureDir(path.dirname(deprecatedAbs));
+        await fs.move(targetAbs, deprecatedAbs, { overwrite: false });
+        console.log(chalk.gray(`  Soft-remove: chuyển vào _deprecated/${path.basename(targetRelPath)}`));
+    }
+
+    return docsBranchCommand.submitDocs({
+        title: options.title,
+        description: options.description || `Remove memory: ${slug}. Lý do: ${options.reason || '(không ghi lý do)'}`,
+        repo: 'AK-Docs', yes: options.yes,
+    });
+}
+
+function splitList(value, fallback = []) {
+    if (!value) return fallback;
+    if (Array.isArray(value)) return value;
+    return String(value).split(',').map(s => s.trim()).filter(Boolean);
+}
+
+module.exports.store = store;

package/scripts/update.js

@@ -3,6 +3,7 @@ const path = require('path');
 const chalk = require('chalk');
 const { confirm, select } = require('@inquirer/prompts');
 const { syncDocsRepos } = require('./docs-repo');
+const memoryStore = require('./memory-store');
 
 const PKG_DIR = path.join(__dirname, '..');
 const PKG_VERSION = require('../package.json').version;
@@ -29,6 +30,17 @@ module.exports = async function update(options = {}) {
     // ── Sync AK-Docs / Shared-Docs sibling repos ──────────────────
     await syncDocsRepos(projectDir);
 
+    // ── Bootstrap 99.Memory/ skeleton if AK-Docs was cloned after init ────
+    const memorySkeleton = await memoryStore.ensureSkeleton(projectDir);
+    if (memorySkeleton.created) {
+        console.log(chalk.green('✓ Đã tạo khung 99.Memory/ trong AK-Docs (chưa có ghi nhớ nào).'));
+        const gitignoreResult = await memoryStore.ensureMemoryGitignored(projectDir);
+        if (memorySkeleton.committed || gitignoreResult.committed) {
+            console.log(chalk.yellow('  ⚠ Đã commit local trên nhánh hiện tại của AK-Docs — `main` là protected branch,'));
+            console.log(chalk.yellow('    hãy tự `git push` khi sẵn sàng (không tự động push).'));
+        }
+    }
+
     const state = await fs.readJson(stateFile);
     const currentVersion = state.current_version;
 

package/scripts/use.js

@@ -636,6 +636,7 @@ async function promptForTaskType(detectedDefault) {
       { name: td("🔍 Investigation",    "Analysis", "Investigate, analyze root cause"),                   value: "investigation" },
       { name: td("📊 Impact Analysis",  "Analysis", "Assess scope and risk of changes"),                  value: "impact-analysis" },
       { name: td("📖 Documentation",    "Document", "Write docs, README, API reference"),                 value: "documentation" },
+      { name: td("📝 Generate Doc/Spec", "Document", "Generate new documentation/Spec (2-gate)"),          value: "gen-doc" },
     ],
     default: detectedDefault || "feature",
   });
@@ -709,7 +710,7 @@ async function manualContext(prefillId = "") {
       { name: td("🔍 Investigation",    "Analysis", "Investigate, analyze root cause"),                   value: "investigation" },
       { name: td("📊 Impact Analysis",  "Analysis", "Assess scope and risk of changes"),                  value: "impact-analysis" },
       { name: td("📖 Documentation",    "Document", "Write docs, README, API reference"),                 value: "documentation" },
-      { name: td("📝 Generate Doc 2 Gate", "Document", "Generate new documentation"),                      value: "gen-doc" },
+      { name: td("📝 Generate Doc/Spec", "Document", "Generate new documentation/Spec (2-gate)"),          value: "gen-doc" },
     ],
     default: existing.taskType || undefined,
   });