@relipa/ai-flow-kit 0.0.1

package/docs/workflows/feature.md

@@ -0,0 +1,123 @@
+# Feature Development Workflow
+
+> See the full workflow at [AIFLOW.md](../../AIFLOW.md)
+> **Gates must pass in order: 1 → 2 → 3 → 4 → 5**
+
+---
+
+## Step 1: Load ticket & AI analyzes (Gate 1)
+
+```bash
+aiflow use PROJ-33                    # from Backlog/Jira
+claude                                # AI auto-starts Gate 1
+```
+
+AI will **automatically**:
+1. Load ticket info from Backlog/Jira
+2. Read source code — understand architecture, related files, patterns
+3. Ask clarifying questions if anything is unclear (one at a time)
+4. Output `plan/[ticket-id]/requirement.md` containing:
+   - Requirements summary (AI's understanding)
+   - Source code analysis (related files, data flow)
+   - **Proposed solution** with options and recommendation
+   - **Impact analysis** — affected areas, risks
+   - **Effort estimate** (S/M/L/XL)
+   - Testing plan
+
+**PM needs to prepare on the ticket:**
+```markdown
+## Description
+Clear business requirement. Who uses it, and for what purpose.
+
+## Acceptance Criteria
+- [ ] [Condition for completion 1]
+- [ ] [Condition for completion 2]
+
+## Mockup / Wireframe
+[Link or UI description]
+
+## Context
+Constraints, business rules specially requiring attention.
+```
+
+**If ticket content is unclear:** AI will ask questions based on source code analysis — not just checking format.
+
+**When satisfied with the requirement document, type:**
+```
+APPROVED
+```
+
+---
+
+## Step 2: Review Implementation Plan (Gate 2)
+
+AI generates a detailed implementation plan:
+- TDD task breakdown (test first → implement → verify)
+- Commit strategy (small, focused commits)
+- Test commands
+
+**When agreed, type:**
+```
+APPROVED
+```
+
+**CODE WILL NOT BE GENERATED BEFORE RECEIVING "APPROVED".**
+
+---
+
+## Step 3: AI Generate Code (Gate 3)
+
+AI performs automatically:
+1. Complex feature (3+ files): `superpowers:subagent-driven-development`
+2. Write tests FIRST → run → confirm FAIL
+3. Implement → tests PASS
+4. Commit each small step
+
+Developer doesn't need to do anything at this step — just monitor.
+
+---
+
+## Step 4: Review Summary (Gate 4)
+
+AI runs:
+1. `superpowers:verification-before-completion` — all tests PASS
+2. `impact-analysis` — no breaking changes outside of scope
+3. Review checklist — all items ticked
+4. Create `plan/[ticket-id]/summary.md`
+
+AI displays summary and waits for developer review.
+
+**If OK, type:**
+```
+APPROVED
+```
+
+**If there are bugs, type:**
+```
+BUG: [specific description]
+```
+- Coding bug → AI fixes → repeat Gate 4
+- Requirement bug → AI returns to Gate 1, update requirement doc
+
+---
+
+## Step 5: Peer Review & PR (Gate 5)
+
+AI invokes `superpowers:requesting-code-review` and guides PR creation.
+
+```bash
+git push origin feature/PROJ-33-feature-name
+# Create PR with full description following the template in AIFLOW.md
+```
+
+Peer reviewer uses the `superpowers:receiving-code-review` skill during review.
+
+---
+
+## Completion Checklist
+
+- [ ] Gate 1 APPROVED — requirement doc with solution, impact, estimate
+- [ ] Gate 2 APPROVED — implementation plan confirmed by developer
+- [ ] Gate 3 done — code + tests are green
+- [ ] Gate 4 APPROVED — summary + checklist complete
+- [ ] Gate 5 done — PR is peer-reviewed and merged

package/docs/workflows/impact-analysis.md

@@ -0,0 +1,13 @@
+# Impact Analysis Workflow
+
+> See the full workflow at [AIFLOW.md](../../AIFLOW.md)
+
+## Quick start
+
+```bash
+aiflow use PROJ-33
+aiflow prompt impact-analysis
+claude
+```
+
+See the details of each Gate in AIFLOW.md — Section "Workflow by Task Type".

package/docs/workflows/investigation.md

@@ -0,0 +1,13 @@
+# Investigation Workflow
+
+> See the full workflow at [AIFLOW.md](../../AIFLOW.md)
+
+## Quick start
+
+```bash
+aiflow use PROJ-33
+aiflow prompt investigation
+claude
+```
+
+See the details of each Gate in AIFLOW.md — Section "Workflow by Task Type".

package/docs/workflows/refactor.md

@@ -0,0 +1,13 @@
+# Refactor Workflow
+
+> See the full workflow at [AIFLOW.md](../../AIFLOW.md)
+
+## Quick start
+
+```bash
+aiflow use PROJ-33
+aiflow prompt refactor
+claude
+```
+
+See the details of each Gate in AIFLOW.md — Section "Workflow by Task Type".

package/index.js

@@ -0,0 +1,27 @@
+// AI Flow Kit - Main Entry Point
+// Exports core utilities for programmatic use
+
+module.exports = {
+    // Configuration
+    ConfigManager: require('./scripts/config'),
+
+    // Task Detection
+    TaskDetector: require('./scripts/detect'),
+
+    // Commands (as modules)
+    init:    require('./scripts/init'),
+    update:  require('./scripts/update'),
+    doctor:  require('./scripts/doctor'),
+    use:     require('./scripts/use'),
+    context: require('./scripts/context'),
+    prompt:  require('./scripts/prompt'),
+    remove:  require('./scripts/remove'),
+    guide:   require('./scripts/guide'),
+
+    // Utilities
+    validate: require('./scripts/validate'),
+    memory:   require('./scripts/memory'),
+
+    // Version
+    version: require('./package.json').version
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@relipa/ai-flow-kit",
+  "version": "0.0.1",
+  "description": "All-in-one AI Flow Kit for team development with Claude AI - skills, templates, and MCP adapters",
+  "author": "Relipa AI Team",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.com/"
+  },
+  "license": "ISC",
+  "type": "commonjs",
+  "main": "index.js",
+  "bin": {
+    "aiflow": "./bin/aiflow.js"
+  },
+  "files": [
+    "bin",
+    "custom",
+    "scripts",
+    "upstream",
+    "docs",
+    "package.json",
+    "index.js",
+    "README.md",
+    "QUICK_START.md",
+    "AIFLOW.md",
+    "CONTRIBUTING.md",
+    "IMPLEMENTATION_SUMMARY.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "ai",
+    "claude",
+    "development",
+    "workflow",
+    "superpowers",
+    "mcp",
+    "team",
+    "productivity"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.relipa.vn/ai/ai-flow-kit"
+  },
+  "bugs": {
+    "url": "https://gitlab.relipa.vn/ai/ai-flow-kit/-/issues"
+  },
+  "homepage": "https://gitlab.relipa.vn/ai/ai-flow-kit",
+  "engines": {
+    "node": ">=14.0.0",
+    "npm": ">=6.0.0"
+  },
+  "scripts": {
+    "aiflow": "node bin/aiflow.js",
+    "test": "echo \"Add tests in future\" && exit 0",
+    "lint": "echo \"Add linting in future\" && exit 0",
+    "docs": "echo \"Documentation available in ./docs\"",
+    "publish": "npm publish"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.2",
+    "chalk": "^4.1.2",
+    "commander": "^14.0.3",
+    "fs-extra": "^11.3.4",
+    "semver": "^7.7.4"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2"
+  }
+}

package/scripts/config.js

@@ -0,0 +1,317 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class ConfigManager {
+    constructor() {
+        this.globalConfigPath = path.join(
+            process.env.HOME || process.env.USERPROFILE || process.env.HOMEPATH,
+            '.claude',
+            'ai-flow-kit.json'
+        );
+        this.projectConfigPath = path.join(process.cwd(), '.aiflowrc.json');
+        this.cache = {};
+    }
+
+    /**
+     * Load configuration with proper priority:
+     * 1. Environment variables
+     * 2. CLI flags
+     * 3. Project config (.aiflowrc.json)
+     * 4. Global config
+     * 5. Defaults
+     */
+    async load(cliFlags = {}) {
+        const defaults = this.getDefaults();
+        const globalConfig = await this.loadFile(this.globalConfigPath) || {};
+        const projectConfig = await this.loadFile(this.projectConfigPath) || {};
+        const envConfig = this.loadFromEnv();
+
+        // Merge with proper precedence
+        this.cache = {
+            ...defaults,
+            ...globalConfig,
+            ...projectConfig,
+            ...envConfig,
+            ...cliFlags
+        };
+
+        return this.cache;
+    }
+
+    /**
+     * Get configuration value with nested path support
+     * e.g., get('mcp.timeout') → 30000
+     */
+    get(path, defaultValue = null) {
+        const parts = path.split('.');
+        let value = this.cache;
+
+        for (const part of parts) {
+            if (value && typeof value === 'object' && part in value) {
+                value = value[part];
+            } else {
+                return defaultValue;
+            }
+        }
+
+        return value;
+    }
+
+    /**
+     * Load environment variables with AIFLOW_ prefix
+     */
+    loadFromEnv() {
+        const envConfig = {};
+
+        // Map environment variables to config
+        const envMap = {
+            'AIFLOW_TEAM': 'team',
+            'AIFLOW_MODEL': 'defaultModel',
+            'AIFLOW_ADAPTERS': 'adapters',
+            'AIFLOW_FRAMEWORKS': 'frameworks',
+            'AIFLOW_AUTO_DETECT': 'autoDetectTasks',
+            'AIFLOW_STRICT_MODE': 'strictMode',
+            'AIFLOW_DEBUG': 'debug',
+            'AIFLOW_VERBOSE': 'verbose'
+        };
+
+        for (const [envKey, configKey] of Object.entries(envMap)) {
+            if (process.env[envKey]) {
+                const value = process.env[envKey];
+                // Parse comma-separated lists
+                if (configKey === 'adapters' || configKey === 'frameworks') {
+                    envConfig[configKey] = value.split(',').map(s => s.trim());
+                }
+                // Parse booleans
+                else if (value === 'true' || value === 'false') {
+                    envConfig[configKey] = value === 'true';
+                }
+                // Parse numbers
+                else if (!isNaN(value)) {
+                    envConfig[configKey] = parseInt(value);
+                }
+                else {
+                    envConfig[configKey] = value;
+                }
+            }
+        }
+
+        return envConfig;
+    }
+
+    /**
+     * Load configuration from file
+     */
+    async loadFile(filePath) {
+        try {
+            if (await fs.pathExists(filePath)) {
+                return await fs.readJson(filePath);
+            }
+        } catch (err) {
+            console.warn(`Warning: Could not load config from ${filePath}`);
+        }
+        return null;
+    }
+
+    /**
+     * Save project configuration
+     */
+    async saveProject(config) {
+        await fs.ensureDir(path.dirname(this.projectConfigPath));
+        await fs.writeJson(this.projectConfigPath, config, { spaces: 2 });
+    }
+
+    /**
+     * Save global configuration
+     */
+    async saveGlobal(config) {
+        await fs.ensureDir(path.dirname(this.globalConfigPath));
+        await fs.writeJson(this.globalConfigPath, config, { spaces: 2 });
+    }
+
+    /**
+     * Default configuration
+     */
+    getDefaults() {
+        return {
+            team: 'default-team',
+            description: 'Default team configuration',
+            adapters: [],
+            frameworks: [],
+            customSkills: [],
+            defaultModel: 'claude-opus-4-6',
+            autoDetectTasks: true,
+            strictMode: false,
+            contextTemplate: 'standard',
+            debug: false,
+            verbose: false,
+
+            // MCP Configuration
+            mcp: {
+                timeout: 30000,
+                retries: 3,
+                fallback: 'manual'
+            },
+
+            // Context Configuration
+            context: {
+                includeGitHistory: true,
+                includeFileTree: true,
+                maxFileSize: 1000000,
+                cacheContexts: true,
+                cacheTTL: 86400
+            },
+
+            // Prompting Configuration
+            prompting: {
+                language: 'english',
+                detail: 'comprehensive',
+                examples: true,
+                bestPractices: true,
+                warningLevel: 'medium'
+            },
+
+            // Validation Configuration
+            validation: {
+                enabled: true,
+                ruleSet: 'default',
+                autoFix: false,
+                reportLevel: 'warning'
+            },
+
+            // Task Detection
+            detection: {
+                confidence_threshold: 0.8,
+                fallback: 'ask',
+                debug: false
+            },
+
+            // Memory System
+            memory: {
+                enabled: true,
+                autoLoadRelevant: true,
+                maxMemorySize: 1000000,
+                persistPath: '.aiflow/memory'
+            }
+        };
+    }
+
+    /**
+     * Validate configuration
+     */
+    validate(config) {
+        const errors = [];
+
+        if (config.adapters && !Array.isArray(config.adapters)) {
+            errors.push('adapters must be an array');
+        }
+
+        if (config.frameworks && !Array.isArray(config.frameworks)) {
+            errors.push('frameworks must be an array');
+        }
+
+        if (config.defaultModel && typeof config.defaultModel !== 'string') {
+            errors.push('defaultModel must be a string');
+        }
+
+        if (typeof config.autoDetectTasks !== 'boolean') {
+            errors.push('autoDetectTasks must be boolean');
+        }
+
+        if (typeof config.strictMode !== 'boolean') {
+            errors.push('strictMode must be boolean');
+        }
+
+        if (config.mcp && typeof config.mcp !== 'object') {
+            errors.push('mcp must be an object');
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+
+    /**
+     * Get all configured adapters
+     */
+    getAdapters() {
+        return this.get('adapters', []);
+    }
+
+    /**
+     * Get all configured frameworks
+     */
+    getFrameworks() {
+        return this.get('frameworks', []);
+    }
+
+    /**
+     * Check if adapter is configured
+     */
+    hasAdapter(name) {
+        return this.getAdapters().includes(name);
+    }
+
+    /**
+     * Check if framework is configured
+     */
+    hasFramework(name) {
+        return this.getFrameworks().includes(name);
+    }
+
+    /**
+     * Get configured custom skills
+     */
+    getCustomSkills() {
+        return this.get('customSkills', []);
+    }
+
+    /**
+     * Check if in strict mode
+     */
+    isStrictMode() {
+        return this.get('strictMode', false);
+    }
+
+    /**
+     * Check if auto-detect is enabled
+     */
+    isAutoDetectEnabled() {
+        return this.get('autoDetectTasks', true);
+    }
+
+    /**
+     * Merge custom config with defaults
+     */
+    merge(customConfig) {
+        return { ...this.getDefaults(), ...customConfig };
+    }
+
+    /**
+     * Create template config for getting started
+     */
+    getTemplateConfig(framework = 'generic', adapters = []) {
+        return {
+            team: 'my-team',
+            description: `Configuration for team projects`,
+            adapters: adapters.length > 0 ? adapters : [],
+            frameworks: framework !== 'generic' ? [framework] : [],
+            customSkills: ['investigate-bug', 'impact-analysis'],
+            defaultModel: 'claude-opus-4-6',
+            autoDetectTasks: true,
+            strictMode: false,
+            contextTemplate: 'standard',
+            prompting: {
+                language: 'english',
+                detail: 'comprehensive'
+            },
+            validation: {
+                enabled: true,
+                ruleSet: 'default'
+            }
+        };
+    }
+}
+
+module.exports = ConfigManager;

package/scripts/context.js

@@ -0,0 +1,117 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+const PROJECT_DIR  = process.cwd();
+const CONTEXT_DIR  = path.join(PROJECT_DIR, '.claude', 'context');
+const HISTORY_DIR  = path.join(CONTEXT_DIR, 'history');
+const CURRENT_FILE = path.join(CONTEXT_DIR, 'current.json');
+
+// ──────────────────────────────────────────────────────────────
+// Entry point — called from bin/aiflow.js
+// ──────────────────────────────────────────────────────────────
+
+module.exports = async function context(action, options = {}) {
+    // Normalise: commander passes the positional arg as `action`,
+    // but flags like --list/--show may also indicate the action.
+    const cmd = action || (options.list ? 'list' : options.show ? 'show' : null);
+
+    try {
+        if (cmd === 'list' || options.list) return await listContexts();
+        if (cmd === 'show' || options.show) return await showCurrent();
+        if (cmd === 'save' || options.save) return await saveCurrent(options.save || cmd);
+        if (options.load)                   return await loadContext(options.load);
+        if (options.delete)                 return await deleteContext(options.delete);
+        if (cmd === 'clear' || options.clear) return await clearContexts();
+
+        console.log(chalk.yellow('Usage: aiflow context <list|show|save <name>|clear>'));
+        console.log(chalk.gray('       aiflow context --load <name>'));
+        console.log(chalk.gray('       aiflow context --delete <name>'));
+    } catch (err) {
+        console.error(chalk.red(`Error: ${err.message}`));
+    }
+};
+
+// ──────────────────────────────────────────────────────────────
+// Commands
+// ──────────────────────────────────────────────────────────────
+
+async function listContexts() {
+    await fs.ensureDir(HISTORY_DIR);
+    const files = (await fs.readdir(HISTORY_DIR)).filter(f => f.endsWith('.json'));
+
+    if (!files.length) {
+        console.log(chalk.gray('No saved contexts.'));
+        return;
+    }
+
+    console.log(chalk.cyan('\nSaved contexts:\n'));
+    for (const file of files) {
+        const name = file.replace(/\.json$/, '');
+        const ctx  = await fs.readJson(path.join(HISTORY_DIR, file)).catch(() => ({}));
+        const label = ctx.title ? ctx.title.substring(0, 60) : '(no title)';
+        console.log(`  ${chalk.white(name.padEnd(20))} ${chalk.gray(label)}`);
+    }
+    console.log();
+}
+
+async function showCurrent() {
+    if (!(await fs.pathExists(CURRENT_FILE))) {
+        console.log(chalk.yellow('No current context. Run `aiflow use <ticket>` first.'));
+        return;
+    }
+    const ctx = await fs.readJson(CURRENT_FILE);
+    console.log(chalk.cyan('\nCurrent context:\n'));
+    console.log(JSON.stringify(ctx, null, 2));
+}
+
+async function saveCurrent(name) {
+    if (!name || name === 'save') {
+        console.log(chalk.red('Provide a name: aiflow context save <name>'));
+        return;
+    }
+    if (!(await fs.pathExists(CURRENT_FILE))) {
+        console.log(chalk.yellow('No current context to save. Run `aiflow use <ticket>` first.'));
+        return;
+    }
+    await fs.ensureDir(HISTORY_DIR);
+    const dest = path.join(HISTORY_DIR, `${sanitize(name)}.json`);
+    await fs.copy(CURRENT_FILE, dest);
+    console.log(chalk.green(`✓ Context saved as: ${name}`));
+}
+
+async function loadContext(name) {
+    await fs.ensureDir(HISTORY_DIR);
+    const src = path.join(HISTORY_DIR, `${sanitize(name)}.json`);
+    if (!(await fs.pathExists(src))) {
+        console.log(chalk.red(`Context not found: ${name}`));
+        return;
+    }
+    await fs.ensureDir(CONTEXT_DIR);
+    await fs.copy(src, CURRENT_FILE, { overwrite: true });
+    console.log(chalk.green(`✓ Loaded context: ${name}`));
+}
+
+async function deleteContext(name) {
+    const target = path.join(HISTORY_DIR, `${sanitize(name)}.json`);
+    if (!(await fs.pathExists(target))) {
+        console.log(chalk.yellow(`Context not found: ${name}`));
+        return;
+    }
+    await fs.remove(target);
+    console.log(chalk.green(`✓ Deleted context: ${name}`));
+}
+
+async function clearContexts() {
+    await fs.ensureDir(HISTORY_DIR);
+    await fs.emptyDir(HISTORY_DIR);
+    console.log(chalk.green('✓ Cleared all saved contexts.'));
+}
+
+// ──────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────
+
+function sanitize(name) {
+    return name.toLowerCase().replace(/[^\w-]/g, '-').replace(/-+/g, '-').substring(0, 60);
+}