@relipa/ai-flow-kit 0.1.1 → 0.1.2

package/docs/common/CHANGELOG.md

@@ -7,6 +7,38 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [0.1.2] - 2026-06-13
+
+### Added
+
+- **`python-ml` framework type** — New framework option for Python ML projects (scikit-learn / PyTorch / TensorFlow / Keras / MLflow / Wandb). Auto-detected from `requirements.txt` or `pyproject.toml` when any of the following dependencies are found: `torch`, `scikit-learn`, `sklearn`, `tensorflow`, `keras`, `mlflow`, `wandb`. Uses a dedicated gate workflow (`ml-gate-workflow.md`) tailored for ML iteration cycles (experiment → evaluate → iterate) instead of the standard software-development gate workflow. Select via `ak init` checkbox or `ak init -f python-ml`.
+- **Task type selector in `ak use`** — After loading a ticket from Backlog, Jira, a local file, or manual entry, `ak use` now prompts the developer to confirm or change the task type via an interactive list (Bug Fix, Feature, Investigation, Refactor, Impact Analysis, Documentation). The type is auto-detected from the ticket title/issue type first and pre-selected as the default. The chosen value is saved to `.aiflow/context/current.json` as `taskType` and is available to the gate workflow throughout the session.
+- **Telemetry warning on `ak use`** — If telemetry logging is not yet enabled, `ak use` now prints a yellow warning at startup so developers know their activity is not being tracked:
+  ```
+  ⚠  Telemetry logging is not enabled. Developer activity will not be tracked.
+     Run: ak telemetry enable  to set up team productivity tracking.
+  ```
+  The check is wrapped in try/catch and never blocks the command. Silently skipped when telemetry is already enabled.
+- **Backup before overwrite (`aiflow update` / `aiflow init`)** — Before overwriting any AI instruction file (CLAUDE.md, GEMINI.md, `.cursorrules`, `.github/copilot-instructions.md`), the current file is now backed up to `.aiflow/bk/YYYY-MM-DD_HH-MM_<filename>`. Multiple backups accumulate across runs, providing a full history to roll back to.
+- **Single upfront confirm on update** — Instead of asking per-file, `aiflow update` and `aiflow init` now show a single summary of all files that will be overwritten, then ask for one confirmation before proceeding. This replaces the per-file prompt sequence that was easy to accidentally skip.
+
+### Changed
+
+- **Framework conventions included in single-framework CLAUDE.md** — Previously, the framework template (e.g. Spring Boot coding standards, architecture rules) was only appended to CLAUDE.md in multi-framework projects. Single-framework projects got only the tool header + skill registry + gate workflow, losing all stack-specific conventions. The framework template is now always embedded for single-framework setups.
+- **`aiflow update` no longer wipes `.claude/` directory** — Previously `update` called `fs.emptyDir('.claude/')` which deleted `.claude/settings.json`, destroying the SessionStart/SessionEnd/PreToolUse hooks configuration. Update now empties only `.claude/skills/` and re-copies skills there, leaving `settings.json` and other files untouched.
+
+### Fixed
+
+- **Critical: `aiflow update` / `aiflow init` did not update CLAUDE.md or GEMINI.md** — Three compounding root causes:
+  1. Old `state.json` wrote `framework: "spring-boot"` (singular string). New code read `state.frameworks` (plural array), got `undefined`, fell back to `[]`, and never called `setupFramework` — so no AI instruction file was ever written or updated.
+  2. `aiflow init` called `setupFramework` without `force: true`, triggering per-file interactive prompts. Users who pressed No (or were surprised by the overwrite prompt) silently skipped the update.
+  3. `aiflow update`'s old per-file confirm dialogs caused the same silent skip.
+  All three are fixed: singular→plural fallback added everywhere `state.frameworks` is read; both `init` and `update` now use `force: true`; the update path is backup-then-overwrite.
+- **Stale skill registry paths in CLAUDE.md** — After upgrading the package, CLAUDE.md still referenced `.aiflow/versions/0.1.1/skills/...` instead of the current `.claude/skills/...` paths. This caused Claude to fail when trying to load skills. Fixed as part of the forced-overwrite update flow above.
+- **`state.framework` (singular) not recognized after upgrade** — `aiflow update`, `aiflow init` re-run, and `ak sync-skills` all read `state.frameworks` (plural). Projects initialized before the plural key was introduced had only `framework: "spring-boot"` in state.json, causing the framework to be silently dropped and `setupFramework` to never run. Fixed with a fallback: `state.frameworks || (state.framework ? [state.framework] : [])` in `update.js`, `init.js`, and `aiflow.js`.
+
+---
+
 ## [0.1.1] - 2026-06-08
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relipa/ai-flow-kit",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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;