@relipa/ai-flow-kit 0.1.1 → 0.1.2-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relipa/ai-flow-kit",
-  "version": "0.1.1",
+  "version": "0.1.2-beta.0",
   "description": "All-in-one AI Flow Kit for team development with Claude AI - skills, templates, and MCP adapters",
   "author": "Example Team",
   "publishConfig": {

package/scripts/detect.js

@@ -1,239 +1,239 @@
-const chalk = require('chalk');
-
-class TaskDetector {
-    constructor() {
-        this.taskTypes = {
-            'bug-fix': {
-                keywords: [
-                    'bug', 'error', 'broken', 'crash', 'fail', 'failed', 'failure',
-                    'issue', 'problem', 'wrong', 'not working', 'doesn\'t work',
-                    'can\'t', 'cannot', 'regression', 'fixing', 'fix',
-                    'exception', 'bug report'
-                ],
-                antiKeywords: ['add', 'create', 'new feature', 'build'],
-                icon: '🐛',
-                description: 'Fixing production issues'
-            },
-            'feature': {
-                keywords: [
-                    'add', 'create', 'build', 'new', 'implement', 'feature',
-                    'new feature', 'feature request', 'capability', 'support for',
-                    'enable', 'make it possible', 'allow', 'user story'
-                ],
-                antiKeywords: ['fix', 'bug', 'broken', 'error'],
-                icon: '✨',
-                description: 'Building new features'
-            },
-            'refactor': {
-                keywords: [
-                    'refactor', 'improve', 'optimize', 'clean up', 'cleanup',
-                    'simplify', 'reorganize', 'reorganise', 'redesign', 'restructure',
-                    'modernize', 'upgrade', 'update', 'rework', 'rewrite',
-                    'performance', 'efficient', 'better', 'enhancement'
-                ],
-                antiKeywords: ['bug', 'broken', 'feature'],
-                icon: '♻️',
-                description: 'Improving existing code'
-            },
-            'investigation': {
-                keywords: [
-                    'investigate', 'analyze', 'analysis', 'understand', 'how does',
-                    'why', 'trace', 'explore', 'research', 'find out', 'examine',
-                    'check', 'review', 'audit', 'assessment'
-                ],
-                antiKeywords: ['fix', 'build', 'create'],
-                icon: '🔍',
-                description: 'Analyzing code and systems'
-            },
-            'impact-analysis': {
-                keywords: [
-                    'impact', 'affect', 'affected', 'breaking', 'breaking change',
-                    'scope', 'scope of change', 'side effect', 'consequence',
-                    'dependent', 'dependency', 'risk', 'assess'
-                ],
-                antiKeywords: [],
-                icon: '📊',
-                description: 'Assessing change impact'
-            },
-            'documentation': {
-                keywords: [
-                    'document', 'readme', 'guide', 'tutorial',
-                    'documentation', 'write doc', 'comment', 'docstring',
-                    'explain', 'api doc', 'reference'
-                ],
-                antiKeywords: ['code'],
-                icon: '📖',
-                description: 'Writing documentation'
-            }
-        };
-    }
-
-    /**
-     * Detect task type from description
-     * Returns: { type, confidence, keywords, suggestions }
-     */
-    detect(description, confidenceThreshold = 0.8) {
-        if (!description || typeof description !== 'string') {
-            return this.getDefaultResult();
-        }
-
-        const lowerDesc = description.toLowerCase();
-        const scores = {};
-
-        // Score each task type
-        for (const [type, config] of Object.entries(this.taskTypes)) {
-            scores[type] = this.scoreType(lowerDesc, config);
-        }
-
-        // Find best match
-        const sorted = Object.entries(scores)
-            .sort(([, scoreA], [, scoreB]) => scoreB - scoreA);
-
-        if (!sorted.length || sorted[0][1] === 0) {
-            return this.getDefaultResult();
-        }
-
-        const [bestType, score] = sorted[0];
-        const confidence = Math.min(score, 1.0);
-
-        return {
-            type: bestType,
-            confidence: Math.round(confidence * 100) / 100,
-            confidence_percent: Math.round(confidence * 100),
-            icon: this.taskTypes[bestType].icon,
-            description: this.taskTypes[bestType].description,
-            keywords: this.findMatchingKeywords(lowerDesc, this.taskTypes[bestType]),
-            suggestions: sorted.slice(1, 3).map(([t, s]) => ({
-                type: t,
-                confidence: Math.round(s * 100) / 100
-            })),
-            isConfident: confidence >= confidenceThreshold,
-            detectedKeywords: this.findAllMatchedKeywords(lowerDesc)
-        };
-    }
-
-    /**
-     * Score a task type based on description
-     */
-    scoreType(description, config) {
-        let score = 0;
-
-        // Count matching keywords
-        for (const keyword of config.keywords) {
-            if (description.includes(keyword)) {
-                score += 0.5;
-            }
-        }
-
-        // Penalize anti-keywords
-        for (const antiKeyword of config.antiKeywords) {
-            if (description.includes(antiKeyword)) {
-                score -= 0.3;
-            }
-        }
-
-        // Normalize score
-        return Math.max(0, Math.min(1, score / Math.max(1, config.keywords.length / 3)));
-    }
-
-    /**
-     * Find which keywords matched in description
-     */
-    findMatchingKeywords(description, config) {
-        const matches = [];
-        for (const keyword of config.keywords) {
-            if (description.includes(keyword)) {
-                matches.push(keyword);
-            }
-        }
-        return matches.slice(0, 5); // Top 5 matches
-    }
-
-    /**
-     * Find all matched keywords across all types
-     */
-    findAllMatchedKeywords(description) {
-        const allKeywords = {};
-        for (const [type, config] of Object.entries(this.taskTypes)) {
-            const matched = this.findMatchingKeywords(description, config);
-            if (matched.length > 0) {
-                allKeywords[type] = matched;
-            }
-        }
-        return allKeywords;
-    }
-
-    /**
-     * Default result when detection fails
-     */
-    getDefaultResult() {
-        return {
-            type: 'unknown',
-            confidence: 0,
-            confidence_percent: 0,
-            icon: '❓',
-            description: 'Unknown task type',
-            keywords: [],
-            suggestions: [],
-            isConfident: false,
-            detectedKeywords: {}
-        };
-    }
-
-    /**
-     * Get formatted output for CLI
-     */
-    formatOutput(result, verbose = false) {
-        if (result.type === 'unknown') {
-            return `${result.icon} Could not detect task type\n\nPlease provide more details or specify task type explicitly:\n  aiflow prompt bug-fix\n  aiflow prompt feature\n  aiflow prompt investigation`;
-        }
-
-        let output = `${result.icon} ${result.type.toUpperCase()} (${result.confidence_percent}% confidence)\n\n`;
-
-        if (verbose) {
-            output += `Description: ${result.description}\n`;
-            output += `Detected keywords:\n`;
-            for (const keyword of result.keywords.slice(0, 5)) {
-                output += `  - ${keyword}\n`;
-            }
-
-            if (result.suggestions.length > 0) {
-                output += `\nOther possibilities:\n`;
-                for (const sugg of result.suggestions) {
-                    output += `  - ${sugg.type} (${Math.round(sugg.confidence * 100)}%)\n`;
-                }
-            }
-        }
-
-        output += `\nSuggested skill: ${result.type}\n`;
-        output += `\nNext: aiflow prompt ${result.type}`;
-
-        return output;
-    }
-
-    /**
-     * Export all task types for reference
-     */
-    getTaskTypes() {
-        return this.taskTypes;
-    }
-
-    /**
-     * Get task type by name
-     */
-    getTaskType(name) {
-        return this.taskTypes[name] || null;
-    }
-
-    /**
-     * Get available task types
-     */
-    getAvailableTypes() {
-        return Object.keys(this.taskTypes).map(type => ({
-            name: type,
-            ...this.taskTypes[type]
-        }));
-    }
-}
-
-module.exports = TaskDetector;
+const chalk = require('chalk');
+
+class TaskDetector {
+    constructor() {
+        this.taskTypes = {
+            'bug-fix': {
+                keywords: [
+                    'bug', 'error', 'broken', 'crash', 'fail', 'failed', 'failure',
+                    'issue', 'problem', 'wrong', 'not working', 'doesn\'t work',
+                    'can\'t', 'cannot', 'regression', 'fixing', 'fix',
+                    'exception', 'bug report'
+                ],
+                antiKeywords: ['add', 'create', 'new feature', 'build'],
+                icon: '🐛',
+                description: 'Fixing production issues'
+            },
+            'feature': {
+                keywords: [
+                    'add', 'create', 'build', 'new', 'implement', 'feature',
+                    'new feature', 'feature request', 'capability', 'support for',
+                    'enable', 'make it possible', 'allow', 'user story'
+                ],
+                antiKeywords: ['fix', 'bug', 'broken', 'error'],
+                icon: '✨',
+                description: 'Building new features'
+            },
+            'refactor': {
+                keywords: [
+                    'refactor', 'improve', 'optimize', 'clean up', 'cleanup',
+                    'simplify', 'reorganize', 'reorganise', 'redesign', 'restructure',
+                    'modernize', 'upgrade', 'update', 'rework', 'rewrite',
+                    'performance', 'efficient', 'better', 'enhancement'
+                ],
+                antiKeywords: ['bug', 'broken', 'feature'],
+                icon: '♻️',
+                description: 'Improving existing code'
+            },
+            'investigation': {
+                keywords: [
+                    'investigate', 'analyze', 'analysis', 'understand', 'how does',
+                    'why', 'trace', 'explore', 'research', 'find out', 'examine',
+                    'check', 'review', 'audit', 'assessment'
+                ],
+                antiKeywords: ['fix', 'build', 'create'],
+                icon: '🔍',
+                description: 'Analyzing code and systems'
+            },
+            'impact-analysis': {
+                keywords: [
+                    'impact', 'affect', 'affected', 'breaking', 'breaking change',
+                    'scope', 'scope of change', 'side effect', 'consequence',
+                    'dependent', 'dependency', 'risk', 'assess'
+                ],
+                antiKeywords: [],
+                icon: '📊',
+                description: 'Assessing change impact'
+            },
+            'documentation': {
+                keywords: [
+                    'document', 'readme', 'guide', 'tutorial',
+                    'documentation', 'write doc', 'comment', 'docstring',
+                    'explain', 'api doc', 'reference'
+                ],
+                antiKeywords: ['code'],
+                icon: '📖',
+                description: 'Writing documentation'
+            }
+        };
+    }
+
+    /**
+     * Detect task type from description
+     * Returns: { type, confidence, keywords, suggestions }
+     */
+    detect(description, confidenceThreshold = 0.8) {
+        if (!description || typeof description !== 'string') {
+            return this.getDefaultResult();
+        }
+
+        const lowerDesc = description.toLowerCase();
+        const scores = {};
+
+        // Score each task type
+        for (const [type, config] of Object.entries(this.taskTypes)) {
+            scores[type] = this.scoreType(lowerDesc, config);
+        }
+
+        // Find best match
+        const sorted = Object.entries(scores)
+            .sort(([, scoreA], [, scoreB]) => scoreB - scoreA);
+
+        if (!sorted.length || sorted[0][1] === 0) {
+            return this.getDefaultResult();
+        }
+
+        const [bestType, score] = sorted[0];
+        const confidence = Math.min(score, 1.0);
+
+        return {
+            type: bestType,
+            confidence: Math.round(confidence * 100) / 100,
+            confidence_percent: Math.round(confidence * 100),
+            icon: this.taskTypes[bestType].icon,
+            description: this.taskTypes[bestType].description,
+            keywords: this.findMatchingKeywords(lowerDesc, this.taskTypes[bestType]),
+            suggestions: sorted.slice(1, 3).map(([t, s]) => ({
+                type: t,
+                confidence: Math.round(s * 100) / 100
+            })),
+            isConfident: confidence >= confidenceThreshold,
+            detectedKeywords: this.findAllMatchedKeywords(lowerDesc)
+        };
+    }
+
+    /**
+     * Score a task type based on description
+     */
+    scoreType(description, config) {
+        let score = 0;
+
+        // Count matching keywords
+        for (const keyword of config.keywords) {
+            if (description.includes(keyword)) {
+                score += 0.5;
+            }
+        }
+
+        // Penalize anti-keywords
+        for (const antiKeyword of config.antiKeywords) {
+            if (description.includes(antiKeyword)) {
+                score -= 0.3;
+            }
+        }
+
+        // Normalize score
+        return Math.max(0, Math.min(1, score / Math.max(1, config.keywords.length / 3)));
+    }
+
+    /**
+     * Find which keywords matched in description
+     */
+    findMatchingKeywords(description, config) {
+        const matches = [];
+        for (const keyword of config.keywords) {
+            if (description.includes(keyword)) {
+                matches.push(keyword);
+            }
+        }
+        return matches.slice(0, 5); // Top 5 matches
+    }
+
+    /**
+     * Find all matched keywords across all types
+     */
+    findAllMatchedKeywords(description) {
+        const allKeywords = {};
+        for (const [type, config] of Object.entries(this.taskTypes)) {
+            const matched = this.findMatchingKeywords(description, config);
+            if (matched.length > 0) {
+                allKeywords[type] = matched;
+            }
+        }
+        return allKeywords;
+    }
+
+    /**
+     * Default result when detection fails
+     */
+    getDefaultResult() {
+        return {
+            type: 'unknown',
+            confidence: 0,
+            confidence_percent: 0,
+            icon: '❓',
+            description: 'Unknown task type',
+            keywords: [],
+            suggestions: [],
+            isConfident: false,
+            detectedKeywords: {}
+        };
+    }
+
+    /**
+     * Get formatted output for CLI
+     */
+    formatOutput(result, verbose = false) {
+        if (result.type === 'unknown') {
+            return `${result.icon} Could not detect task type\n\nPlease provide more details or specify task type explicitly:\n  aiflow prompt bug-fix\n  aiflow prompt feature\n  aiflow prompt investigation`;
+        }
+
+        let output = `${result.icon} ${result.type.toUpperCase()} (${result.confidence_percent}% confidence)\n\n`;
+
+        if (verbose) {
+            output += `Description: ${result.description}\n`;
+            output += `Detected keywords:\n`;
+            for (const keyword of result.keywords.slice(0, 5)) {
+                output += `  - ${keyword}\n`;
+            }
+
+            if (result.suggestions.length > 0) {
+                output += `\nOther possibilities:\n`;
+                for (const sugg of result.suggestions) {
+                    output += `  - ${sugg.type} (${Math.round(sugg.confidence * 100)}%)\n`;
+                }
+            }
+        }
+
+        output += `\nSuggested skill: ${result.type}\n`;
+        output += `\nNext: aiflow prompt ${result.type}`;
+
+        return output;
+    }
+
+    /**
+     * Export all task types for reference
+     */
+    getTaskTypes() {
+        return this.taskTypes;
+    }
+
+    /**
+     * Get task type by name
+     */
+    getTaskType(name) {
+        return this.taskTypes[name] || null;
+    }
+
+    /**
+     * Get available task types
+     */
+    getAvailableTypes() {
+        return Object.keys(this.taskTypes).map(type => ({
+            name: type,
+            ...this.taskTypes[type]
+        }));
+    }
+}
+
+module.exports = TaskDetector;