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

package/docs/common/CHANGELOG.md

@@ -7,6 +7,22 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [0.1.1] - 2026-06-08
+
+### Added
+
+- **Ubuntu / Linux clipboard support in `ak prompt`** — `ak prompt` now copies to the clipboard on native Linux. It auto-detects the display server (Wayland → `wl-copy`, X11 → `xclip` → `xsel`) and the package manager (`apt-get` / `dnf` / `pacman` / `zypper`). When no clipboard tool is installed it prints a clear warning (`⚠ Clipboard tool not found (need: xclip)`), shows the exact install command, and offers to install it via `sudo` then retries the copy. If the user declines or no package manager is found, it falls back to printing the full prompt for manual copy. Previously the command silently failed on Ubuntu when neither `xclip` nor `xsel` was present.
+- **`figma-to-component`: image detection & export** — The skill now scans the Figma node tree for image nodes (`fills[].type === "IMAGE"`, `VECTOR`/`BOOLEAN_OPERATION`, complex non-CSS groups), exports them via `download_figma_images` into `public/assets/figma/`, and records an `imageMap`. Generated components render those nodes with `<Image>` (Next.js) / `<img>` (React/Vue) instead of CSS `background-image`.
+- **`figma-to-component`: MCP availability pre-check (Step 0)** — The skill now verifies `mcp__figma__get_figma_data` / `mcp__figma__download_figma_images` are connected before running, and stops with setup instructions (`aiflow init -a figma` / `-a figma-desktop`) instead of guessing design values from the URL.
+- **`figma-to-component`: CSS tooling detection + design tokens** — Detection now branches on the project's styling approach (Tailwind / CSS Modules / styled-components / vanilla CSS) instead of hardcoding Tailwind, and prefers mapping Figma Styles/Variables to existing project tokens (Tailwind theme keys or CSS custom properties), falling back to arbitrary values only when no token matches.
+- **`figma-to-component`: troubleshooting table** — Added a troubleshooting section covering MCP-not-connected, `403`/token rejected, request timeout (lower `depth`), `404` node-id, empty fills, and unsupported `download_figma_images`.
+
+### Fixed
+
+- **Critical: `figma-to-component` source/installed divergence** — The source skill (`custom/skills/figma-to-component/SKILL.md`) still referenced the non-existent tool names `figma_get_file_nodes` / `figma_get_file_styles` / `figma_get_image` and only had 2-tier framework detection, while the installed `.claude/` copy had been fixed in 0.0.9. The next `aiflow init` / `sync-skills` would have overwritten the working copy with the broken source — re-introducing the 0.0.9 bug. Both copies are now synced to a single canonical version: correct tool names (`get_figma_data` / `download_figma_images`), 4-tier framework detection (App Router / React / Vue / Angular), and the image-export step.
+
+---
+
 ## [0.1.0] - 2026-05-28
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relipa/ai-flow-kit",
-  "version": "0.1.1-beta.0",
+  "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": {
@@ -65,4 +65,4 @@
       "<rootDir>/tests/**/*.test.js"
     ]
   }
-}
+}

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;