flutter-pro-max-cli 1.0.0

package/dist/utils/detect.js

@@ -0,0 +1,80 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export function detectAIType(cwd = process.cwd()) {
+    const detected = [];
+    if (existsSync(join(cwd, '.claude'))) {
+        detected.push('claude');
+    }
+    if (existsSync(join(cwd, '.cursor'))) {
+        detected.push('cursor');
+    }
+    if (existsSync(join(cwd, '.windsurf'))) {
+        detected.push('windsurf');
+    }
+    if (existsSync(join(cwd, '.agent'))) {
+        detected.push('antigravity');
+    }
+    if (existsSync(join(cwd, '.github'))) {
+        detected.push('copilot');
+    }
+    if (existsSync(join(cwd, '.kiro'))) {
+        detected.push('kiro');
+    }
+    if (existsSync(join(cwd, '.codex'))) {
+        detected.push('codex');
+    }
+    if (existsSync(join(cwd, '.roo'))) {
+        detected.push('roocode');
+    }
+    if (existsSync(join(cwd, '.qoder'))) {
+        detected.push('qoder');
+    }
+    if (existsSync(join(cwd, '.gemini'))) {
+        detected.push('gemini');
+    }
+    if (existsSync(join(cwd, '.codebuddy'))) {
+        detected.push('codebuddy');
+    }
+    if (existsSync(join(cwd, '.trae'))) {
+        detected.push('trae');
+    }
+    // Suggest based on what's detected
+    let suggested = null;
+    if (detected.length === 1) {
+        suggested = detected[0];
+    }
+    else if (detected.length > 1) {
+        suggested = 'all';
+    }
+    return { detected, suggested };
+}
+export function getAITypeDescription(aiType) {
+    switch (aiType) {
+        case 'claude':
+            return 'Claude Code (.claude/skills/)';
+        case 'cursor':
+            return 'Cursor (.cursor/commands/)';
+        case 'windsurf':
+            return 'Windsurf (.windsurf/workflows/)';
+        case 'antigravity':
+            return 'Antigravity (.agent/workflows/)';
+        case 'copilot':
+            return 'GitHub Copilot (.github/prompts/)';
+        case 'kiro':
+            return 'Kiro (.kiro/steering/)';
+        case 'codex':
+            return 'Codex (.codex/skills/)';
+        case 'roocode':
+            return 'RooCode (.roo/commands/)';
+        case 'qoder':
+            return 'Qoder (.qoder/rules/)';
+        case 'gemini':
+            return 'Gemini CLI (.gemini/skills/)';
+        case 'codebuddy':
+            return 'CodeBuddy (.codebuddy/commands/)';
+        case 'trae':
+            return 'Trae (.trae/skills/)';
+        case 'all':
+            return 'All AI assistants';
+    }
+}

package/dist/utils/extract.d.ts

@@ -0,0 +1,4 @@
+import type { AIType } from '../types/index.js';
+export declare function extractZip(zipPath: string, destDir: string): Promise<void>;
+export declare function copyFolders(sourceDir: string, targetDir: string, aiType: AIType): Promise<string[]>;
+export declare function cleanup(tempDir: string): Promise<void>;

package/dist/utils/extract.js

@@ -0,0 +1,83 @@
+import { mkdir, rm, access, cp } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { AI_FOLDERS } from '../types/index.js';
+const execAsync = promisify(exec);
+const EXCLUDED_FILES = ['settings.local.json'];
+export async function extractZip(zipPath, destDir) {
+    try {
+        const isWindows = process.platform === 'win32';
+        if (isWindows) {
+            await execAsync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`);
+        }
+        else {
+            await execAsync(`unzip -o "${zipPath}" -d "${destDir}"`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to extract zip: ${error}`);
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function copyFolders(sourceDir, targetDir, aiType) {
+    const copiedFolders = [];
+    const foldersToCopy = aiType === 'all'
+        ? ['.claude', '.cursor', '.windsurf', '.agent', '.github', '.kiro', '.roo', '.codex', '.gemini', '.qoder', '.codebuddy', '.trae', '.shared']
+        : AI_FOLDERS[aiType];
+    // Deduplicate folders (e.g., .shared might be listed multiple times)
+    const uniqueFolders = [...new Set(foldersToCopy)];
+    for (const folder of uniqueFolders) {
+        const sourcePath = join(sourceDir, folder);
+        const targetPath = join(targetDir, folder);
+        // Check if source folder exists
+        const sourceExists = await exists(sourcePath);
+        if (!sourceExists) {
+            continue;
+        }
+        // Create target directory if needed
+        await mkdir(targetPath, { recursive: true });
+        // Filter function to exclude certain files
+        const filterFn = (src) => {
+            const fileName = basename(src);
+            return !EXCLUDED_FILES.includes(fileName);
+        };
+        // Copy recursively
+        try {
+            await cp(sourcePath, targetPath, { recursive: true, filter: filterFn });
+            copiedFolders.push(folder);
+        }
+        catch {
+            // Try shell fallback for older Node versions
+            try {
+                if (process.platform === 'win32') {
+                    await execAsync(`xcopy "${sourcePath}" "${targetPath}" /E /I /Y`);
+                }
+                else {
+                    await execAsync(`cp -r "${sourcePath}/." "${targetPath}"`);
+                }
+                copiedFolders.push(folder);
+            }
+            catch {
+                // Skip if copy fails
+            }
+        }
+    }
+    return copiedFolders;
+}
+export async function cleanup(tempDir) {
+    try {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const logger: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    title: (msg: string) => void;
+    dim: (msg: string) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+export const logger = {
+    info: (msg) => console.log(chalk.blue('info'), msg),
+    success: (msg) => console.log(chalk.green('success'), msg),
+    warn: (msg) => console.log(chalk.yellow('warn'), msg),
+    error: (msg) => console.log(chalk.red('error'), msg),
+    title: (msg) => console.log(chalk.bold.cyan(`\n${msg}\n`)),
+    dim: (msg) => console.log(chalk.dim(msg)),
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "flutter-pro-max-cli",
+    "version": "1.0.0",
+    "description": "CLI to install Flutter Pro Max skill for AI coding assistants",
+    "type": "module",
+    "bin": {
+        "flutter-pro-max": "./dist/index.js"
+    },
+    "files": [
+        "dist",
+        "assets",
+        "LICENSE"
+    ],
+    "scripts": {
+        "sync:assets": "bash scripts/sync-assets.sh",
+        "build": "npm run sync:assets && tsc",
+        "build:bun": "npm run sync:assets && bun build src/index.ts --outdir dist --target node",
+        "dev": "npx ts-node --esm src/index.ts",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "flutter",
+        "dart",
+        "clean-architecture",
+        "riverpod",
+        "bloc",
+        "claude",
+        "cursor",
+        "windsurf",
+        "copilot",
+        "kiro",
+        "roocode",
+        "codex",
+        "qoder",
+        "ai",
+        "skill"
+    ],
+    "author": "",
+    "license": "MIT",
+    "dependencies": {
+        "commander": "^12.1.0",
+        "chalk": "^5.3.0",
+        "ora": "^8.1.1",
+        "prompts": "^2.4.2"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.1.14",
+        "@types/node": "^22.10.1",
+        "@types/prompts": "^2.4.9",
+        "typescript": "^5.7.2"
+    }
+}