@relipa/ai-flow-kit 0.0.1

package/scripts/memory.js

@@ -0,0 +1,247 @@
+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;

package/scripts/prompt.js

@@ -0,0 +1,392 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const PROJECT_DIR  = process.cwd();
+const CURRENT_FILE = path.join(PROJECT_DIR, '.claude', 'context', 'current.json');
+const RULES_DIR    = path.join(PROJECT_DIR, '.rules');
+
+// Prompt templates per task type
+// Each template includes mandatory superpowers skill invocation steps.
+const PROMPT_TEMPLATES = {
+    'bug-fix': {
+        header: 'Fix Bug',
+        instruction: 'Investigate and fix the bug described below.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Bug Fix
+
+Follow gates IN ORDER. Do NOT skip or merge gates.
+
+### GATE 1 — AI Analyze Requirement
+**INVOKE:** \`validate-ticket\` skill
+AI must:
+1. Load ticket context + read source code related to the bug
+2. Trace data flow to form root cause hypothesis (\`superpowers:systematic-debugging\`)
+3. If unclear → ask ONE question at a time, wait for reply
+4. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Bug analysis (current vs expected behavior)
+   - Root cause hypothesis with evidence from source code
+   - Proposed fix approach (options if multiple)
+   - Impact analysis — will the fix break anything else?
+   - Effort estimate (S/M/L/XL)
+   - Testing plan (reproduce bug + verify fix)
+5. Display "GATE 1: Requirement doc ready" → wait for **APPROVED**
+
+### GATE 2 — Implementation Plan (wait for APPROVED)
+**INVOKE:** \`generate-spec\` skill → \`superpowers:writing-plans\`
+- Create TDD task breakdown: test to reproduce bug → fix → verify
+- Display: "GATE 2: Plan ready, type APPROVED to start coding"
+- **DO NOT WRITE CODE until APPROVED received**
+
+### GATE 3 — Code (TDD)
+Only runs after Gate 2 APPROVED.
+1. **INVOKE:** \`superpowers:systematic-debugging\` — confirm root cause
+2. **INVOKE:** \`investigate-bug\` skill — trace Controller→Service→Repository
+3. **INVOKE:** \`superpowers:test-driven-development\` — write failing test to reproduce bug
+4. Implement minimal fix to make test pass
+
+### GATE 4 — AI Self-Review (wait for APPROVED)
+**INVOKE:** \`review-plan\` skill
+1. \`superpowers:verification-before-completion\` — all tests PASS (including old tests)
+2. \`impact-analysis\` skill — fix doesn't cause new bugs elsewhere
+3. Tick \`custom/rules/review-checklist.md\`
+4. Create \`plan/[ticket-id]/summary.md\`
+- Display: "GATE 4: type APPROVED or BUG: [description]"
+- Coding bug → fix → repeat Gate 4
+- Requirement bug → back to Gate 1
+
+### GATE 5 — Peer Review & Done
+Only runs after Gate 4 APPROVED.
+**INVOKE:** \`superpowers:requesting-code-review\` → guide PR creation
+`,
+    },
+    'feature': {
+        header: 'Implement Feature',
+        instruction: 'Implement the feature described below following team rules.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Feature
+
+Follow gates IN ORDER. Do NOT skip or merge gates.
+
+### GATE 1 — AI Analyze Requirement
+**INVOKE:** \`validate-ticket\` skill
+AI must:
+1. Load ticket context + read source code to understand architecture
+2. Investigate related files, data flow, existing patterns
+3. Use \`superpowers:brainstorming\` if solution approach is complex
+4. If unclear → ask ONE question at a time, wait for reply
+5. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Requirements summary (AI's understanding in technical language)
+   - Source code analysis (related files, data flow, patterns)
+   - Proposed solution with options (recommended + alternatives)
+   - Impact analysis — what areas are affected?
+   - Effort estimate (S/M/L/XL) with task breakdown
+   - Testing plan (unit + integration + manual)
+6. Display "GATE 1: Requirement doc ready" → wait for **APPROVED**
+
+### GATE 2 — Implementation Plan (wait for APPROVED)
+**INVOKE:** \`generate-spec\` skill → \`superpowers:writing-plans\`
+- Create TDD task breakdown: test first → implement → verify
+- Define commit strategy (small, focused)
+- Display: "GATE 2: Plan ready, type APPROVED to start coding"
+- **DO NOT WRITE CODE until APPROVED received**
+
+### GATE 3 — Code (TDD)
+Only runs after Gate 2 APPROVED.
+1. Complex feature (3+ files): **INVOKE:** \`superpowers:subagent-driven-development\`
+2. **INVOKE:** \`superpowers:test-driven-development\` — write failing test first
+3. Implement to make tests pass — commit each small step
+
+### GATE 4 — AI Self-Review (wait for APPROVED)
+**INVOKE:** \`review-plan\` skill
+1. \`superpowers:verification-before-completion\` — all tests PASS
+2. \`impact-analysis\` skill — no regressions
+3. Tick \`custom/rules/review-checklist.md\`
+4. Create \`plan/[ticket-id]/summary.md\`
+- Display: "GATE 4: type APPROVED or BUG: [description]"
+- Coding bug → fix → repeat Gate 4
+- Requirement bug → back to Gate 1
+
+### GATE 5 — Peer Review & Done
+Only runs after Gate 4 APPROVED.
+**INVOKE:** \`superpowers:requesting-code-review\` → guide PR creation
+`,
+    },
+    'investigation': {
+        header: 'Investigate',
+        instruction: 'Investigate the topic described below. Document findings before proposing solutions.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Investigation
+
+Investigation stops at Gate 1 — produce requirement doc with findings only, no coding.
+
+### GATE 1 — AI Analyze & Investigate
+**INVOKE:** \`validate-ticket\` skill
+AI must:
+1. Load ticket context + read source code thoroughly
+2. **INVOKE:** \`superpowers:systematic-debugging\` — trace through all layers
+3. **INVOKE:** \`investigate-bug\` skill — trace data flow through all layers
+4. If unclear → ask ONE question at a time
+5. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Investigation scope and approach
+   - Source code analysis (all related files traced)
+   - Findings with evidence (log output, code references)
+   - Root cause (if applicable)
+   - Impact analysis — what areas are affected?
+   - Recommendations and next steps
+   - Effort estimate for proposed fix (if applicable)
+6. Display "GATE 1: Investigation complete" → wait for **APPROVED**
+
+**Do NOT implement any fix.** If fix needed → create new ticket → new workflow.
+`,
+    },
+    'refactor': {
+        header: 'Refactor',
+        instruction: 'Refactor the code described below. Behaviour must be preserved.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Refactor
+
+Follow gates IN ORDER. Do NOT skip or merge gates.
+
+### GATE 1 — AI Analyze Requirement
+**INVOKE:** \`validate-ticket\` skill
+AI must:
+1. Load ticket context + read source code to understand current state
+2. **INVOKE:** \`impact-analysis\` skill — map ALL callers and dependants
+3. If unclear → ask ONE question at a time
+4. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Current state analysis (what exists, what's wrong)
+   - Target state (what it should look like after refactor)
+   - Proposed approach (step-by-step refactor strategy)
+   - Impact analysis — all callers, dependencies, test coverage
+   - Risk assessment — what could break?
+   - Effort estimate (S/M/L/XL)
+5. Display "GATE 1: Requirement doc ready" → wait for **APPROVED**
+
+### GATE 2 — Implementation Plan (wait for APPROVED)
+**INVOKE:** \`generate-spec\` skill → \`superpowers:writing-plans\`
+- Plan: ensure tests cover CURRENT behavior → refactor in steps → verify at each step
+- Display: "GATE 2: Plan ready, type APPROVED to start refactoring"
+- **DO NOT TOUCH CODE until APPROVED received**
+
+### GATE 3 — Refactor (TDD)
+Only runs after Gate 2 APPROVED.
+1. **INVOKE:** \`superpowers:test-driven-development\` — ensure tests cover CURRENT behavior
+2. Refactor incrementally — keep tests green at each step
+3. Commit each step
+
+### GATE 4 — AI Self-Review (wait for APPROVED)
+**INVOKE:** \`review-plan\` skill
+1. \`superpowers:verification-before-completion\` — all tests PASS
+2. \`impact-analysis\` skill — verify no regressions
+3. Tick \`custom/rules/review-checklist.md\`
+4. Create \`plan/[ticket-id]/summary.md\`
+- Display: "GATE 4: type APPROVED or BUG: [description]"
+
+### GATE 5 — Peer Review & Done
+**INVOKE:** \`superpowers:requesting-code-review\` → guide PR creation
+`,
+    },
+    'impact-analysis': {
+        header: 'Impact Analysis',
+        instruction: 'Analyse the scope and impact of the change described below.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Impact Analysis
+
+Impact analysis stops at Gate 1 — produce report only, no coding.
+
+### GATE 1 — AI Analyze & Report
+**INVOKE:** \`validate-ticket\` skill
+AI must:
+1. Load ticket context + read source code thoroughly
+2. Map all dependencies, callers, services, jobs, tests
+3. If unclear → ask ONE question at a time
+4. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Change description and scope
+   - Dependency map (all callers, services, jobs, tests)
+   - Impact level: 🟢 Low / 🟡 Medium / 🔴 High / 🔥 Critical
+   - Breaking changes list
+   - Affected test coverage
+   - Risk assessment with mitigations
+   - Recommendations
+   - Effort estimate for implementation (if applicable)
+5. Display "GATE 1: Impact report complete" → wait for **APPROVED**
+
+**Do NOT make any code changes.** Implementation needs a separate ticket.
+`,
+    },
+    'documentation': {
+        header: 'Write Documentation',
+        instruction: 'Write documentation for the topic described below.',
+        skillWorkflow: `
+## STRICT GATE WORKFLOW — Documentation
+
+### GATE 1 — AI Analyze Requirement
+**INVOKE:** \`validate-ticket\` skill
+AI must:
+1. Load ticket context + read source code
+2. Understand what needs to be documented and for whom
+3. If unclear → ask ONE question at a time
+4. Output \`plan/[ticket-id]/requirement.md\` with:
+   - Documentation scope and target audience
+   - Content outline (sections to cover)
+   - Source code references
+   - Effort estimate
+5. Display "GATE 1: Documentation plan ready" → wait for **APPROVED**
+
+### GATE 2 — Write Documentation
+Only runs after Gate 1 APPROVED.
+Read actual code/tests first — docs must reflect real implementation.
+Write documentation based on approved outline.
+
+### GATE 3 — Review (wait for APPROVED)
+**INVOKE:** \`superpowers:verification-before-completion\`
+Verify docs match code. No outdated examples.
+Display: "GATE 3: Documentation complete. Type APPROVED."
+`,
+    },
+};
+
+// ──────────────────────────────────────────────────────────────
+// Entry point
+// ──────────────────────────────────────────────────────────────
+
+module.exports = async function generatePrompt(type, options = {}) {
+    if (options.list) {
+        console.log(chalk.cyan('\nAvailable prompt types:\n'));
+        for (const [key, tpl] of Object.entries(PROMPT_TEMPLATES)) {
+            console.log(`  ${chalk.white(key.padEnd(18))} ${chalk.gray(tpl.instruction.substring(0, 60))}...`);
+        }
+        console.log();
+        return;
+    }
+
+    // Load context
+    let ctx = null;
+    if (await fs.pathExists(CURRENT_FILE)) {
+        ctx = await fs.readJson(CURRENT_FILE).catch(() => null);
+    }
+
+    // Resolve task type: CLI arg > context > ask user to specify
+    const resolvedType = type || ctx?.taskType;
+    if (!resolvedType || !PROMPT_TEMPLATES[resolvedType]) {
+        console.log(chalk.red(`Unknown or missing prompt type: ${resolvedType || '(none)'}`));
+        console.log(chalk.gray('Run: aiflow prompt --list'));
+        return;
+    }
+
+    const template = PROMPT_TEMPLATES[resolvedType];
+    const rules    = await loadRules();
+
+    const prompt = buildPrompt(template, ctx, rules, options);
+
+    if (options.output) {
+        await fs.writeFile(options.output, prompt, 'utf-8');
+        console.log(chalk.green(`✓ Prompt saved to: ${options.output}`));
+    } else {
+        console.log(chalk.cyan('\n' + '─'.repeat(60)));
+        console.log(prompt);
+        console.log('─'.repeat(60) + '\n');
+        console.log(chalk.gray('Tip: paste this into your Claude session, or use --output <file>'));
+    }
+};
+
+// ──────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────
+
+async function loadRules() {
+    if (!(await fs.pathExists(RULES_DIR))) return '';
+
+    const files = (await fs.readdir(RULES_DIR)).filter(f => f.endsWith('.md'));
+    if (!files.length) return '';
+
+    const parts = [];
+    for (const file of files) {
+        const content = await fs.readFile(path.join(RULES_DIR, file), 'utf-8');
+        parts.push(`### ${file}\n${content.trim()}`);
+    }
+    return parts.join('\n\n');
+}
+
+function buildPrompt(template, ctx, rules, options) {
+    const lang   = options.lang   || 'english';
+    const detail = options.detail || 'standard';
+
+    const lines = [];
+
+    lines.push(`# ${template.header}`);
+    lines.push('');
+    lines.push(`**Task:** ${template.instruction}`);
+    lines.push('');
+
+    // ── Mandatory skill workflow ───────────────────────────────
+    if (template.skillWorkflow) {
+        lines.push(template.skillWorkflow.trim());
+        lines.push('');
+    }
+
+    // ── Context section ────────────────────────────────────────
+    if (ctx) {
+        lines.push('## Context');
+        lines.push('');
+        lines.push(`- **Ticket:** ${ctx.taskId || 'N/A'}`);
+        lines.push(`- **Title:** ${ctx.title || 'N/A'}`);
+        lines.push(`- **Status:** ${ctx.status || 'N/A'}`);
+        lines.push(`- **Assignee:** ${ctx.assignee || 'N/A'}`);
+        lines.push('');
+
+        if (ctx.description) {
+            lines.push('### Description');
+            lines.push('');
+            lines.push(ctx.description.trim());
+            lines.push('');
+        }
+
+        if (ctx.acceptanceCriteria?.length) {
+            lines.push('### Acceptance Criteria');
+            lines.push('');
+            for (const c of ctx.acceptanceCriteria) {
+                lines.push(`- ${c}`);
+            }
+            lines.push('');
+        }
+
+        if (detail === 'comprehensive' && ctx.comments?.length) {
+            lines.push('### Comments');
+            lines.push('');
+            for (const c of ctx.comments) {
+                lines.push(c);
+                lines.push('');
+            }
+        }
+
+        if (ctx.context?.files?.length) {
+            lines.push('### Related Files Mentioned');
+            lines.push('');
+            for (const f of ctx.context.files) {
+                lines.push(`- \`${f}\``);
+            }
+            lines.push('');
+        }
+    } else {
+        lines.push('> No context loaded. Run `aiflow use <ticket>` to load ticket context.');
+        lines.push('');
+    }
+
+    // ── Rules section ──────────────────────────────────────────
+    if (rules) {
+        lines.push('## Team Rules');
+        lines.push('');
+        lines.push(rules);
+        lines.push('');
+    }
+
+    // ── Language instruction ───────────────────────────────────
+    if (lang === 'vietnamese') {
+        lines.push('> **Reply in English.**');
+        lines.push('');
+    }
+
+    return lines.join('\n');
+}