flutter-pro-max-cli 1.0.2 → 2.1.0

package/dist/commands/update.d.ts

@@ -0,0 +1,6 @@
+import type { AIType } from '../types/index.js';
+interface UpdateOptions {
+    ai?: AIType;
+}
+export declare function updateCommand(options: UpdateOptions): Promise<void>;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getLatestRelease } from '../utils/github.js';
+import { logger } from '../utils/logger.js';
+import { initCommand } from './init.js';
+export async function updateCommand(options) {
+    logger.title('🔄 Flutter Pro Max Updater');
+    const spinner = ora('Checking for updates...').start();
+    try {
+        const release = await getLatestRelease();
+        spinner.succeed(`Latest version: ${chalk.cyan(release.tag_name)}`);
+        console.log();
+        logger.info('Running update (same as init with latest version)...');
+        console.log();
+        await initCommand({
+            ai: options.ai,
+            force: true,
+        });
+    }
+    catch (error) {
+        spinner.fail('Update check failed');
+        if (error instanceof Error) {
+            logger.error(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/versions.d.ts

@@ -0,0 +1 @@
+export declare function versionsCommand(): Promise<void>;

package/dist/commands/versions.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchReleases } from '../utils/github.js';
+import { logger } from '../utils/logger.js';
+export async function versionsCommand() {
+    const spinner = ora('Fetching available versions...').start();
+    try {
+        const releases = await fetchReleases();
+        if (releases.length === 0) {
+            spinner.warn('No releases found');
+            return;
+        }
+        spinner.succeed(`Found ${releases.length} version(s)\n`);
+        console.log(chalk.bold('Available versions:\n'));
+        releases.forEach((release, index) => {
+            const isLatest = index === 0;
+            const tag = release.tag_name;
+            const date = new Date(release.published_at).toLocaleDateString();
+            if (isLatest) {
+                console.log(`  ${chalk.green('*')} ${chalk.bold(tag)} ${chalk.dim(`(${date})`)} ${chalk.green('[latest]')}`);
+            }
+            else {
+                console.log(`    ${tag} ${chalk.dim(`(${date})`)}`);
+            }
+        });
+        console.log();
+        logger.dim('Use: flutter-pro-max init --version <tag> to install a specific version');
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch versions');
+        if (error instanceof Error) {
+            logger.error(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
 import { initCommand } from './commands/init.js';
+import { versionsCommand } from './commands/versions.js';
+import { updateCommand } from './commands/update.js';
 import { AI_TYPES } from './types/index.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
 const program = new Command();
 program
     .name('flutter-pro-max')
     .description('CLI to install Flutter Pro Max skill for AI coding assistants')
-    .version('1.0.0');
+    .version(pkg.version);
 program
     .command('init')
     .description('Install Flutter Pro Max skill to current project')
@@ -23,6 +31,24 @@ program
         force: options.force,
     });
 });
+program
+    .command('versions')
+    .description('List available versions')
+    .action(versionsCommand);
+program
+    .command('update')
+    .description('Update Flutter Pro Max to latest version')
+    .option('-a, --ai <type>', `AI assistant type (${AI_TYPES.join(', ')})`)
+    .action(async (options) => {
+    if (options.ai && !AI_TYPES.includes(options.ai)) {
+        console.error(`Invalid AI type: ${options.ai}`);
+        console.error(`Valid types: ${AI_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    await updateCommand({
+        ai: options.ai,
+    });
+});
 // Default command (when run without subcommand)
 program
     .action(async () => {

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
-export type AIType = 'claude' | 'cursor' | 'windsurf' | 'antigravity' | 'copilot' | 'kiro' | 'roocode' | 'codex' | 'qoder' | 'gemini' | 'codebuddy' | 'trae' | 'all';
+export type AIType = 'claude' | 'cursor' | 'windsurf' | 'antigravity' | 'copilot' | 'kiro' | 'roocode' | 'codex' | 'qoder' | 'gemini' | 'codebuddy' | 'trae' | 'opencode' | 'continue' | 'all';
+export type InstallType = 'full' | 'reference';
 export interface Release {
     tag_name: string;
     name: string;
@@ -16,5 +17,23 @@ export interface InstallConfig {
     version?: string;
     force?: boolean;
 }
+export interface PlatformConfig {
+    platform: string;
+    displayName: string;
+    installType: InstallType;
+    folderStructure: {
+        root: string;
+        skillPath: string;
+        filename: string;
+    };
+    scriptPath: string;
+    frontmatter: Record<string, string> | null;
+    sections: {
+        quickReference: boolean;
+    };
+    title: string;
+    description: string;
+    skillOrWorkflow: string;
+}
 export declare const AI_TYPES: AIType[];
 export declare const AI_FOLDERS: Record<Exclude<AIType, 'all'>, string[]>;

package/dist/types/index.js

@@ -1,4 +1,5 @@
-export const AI_TYPES = ['claude', 'cursor', 'windsurf', 'antigravity', 'copilot', 'roocode', 'kiro', 'codex', 'qoder', 'gemini', 'codebuddy', 'trae', 'all'];
+export const AI_TYPES = ['claude', 'cursor', 'windsurf', 'antigravity', 'copilot', 'roocode', 'kiro', 'codex', 'qoder', 'gemini', 'codebuddy', 'trae', 'opencode', 'continue', 'all'];
+// Legacy folder mapping for backward compatibility with ZIP-based installs
 export const AI_FOLDERS = {
     claude: ['.claude', '.shared'],
     cursor: ['.cursor', '.shared'],
@@ -12,4 +13,6 @@ export const AI_FOLDERS = {
     gemini: ['.gemini', '.shared'],
     codebuddy: ['.codebuddy', '.shared'],
     trae: ['.trae', '.shared'],
+    opencode: ['.opencode', '.shared'],
+    continue: ['.continue', '.shared'],
 };

package/dist/utils/detect.js

@@ -38,6 +38,12 @@ export function detectAIType(cwd = process.cwd()) {
     if (existsSync(join(cwd, '.trae'))) {
         detected.push('trae');
     }
+    if (existsSync(join(cwd, '.opencode'))) {
+        detected.push('opencode');
+    }
+    if (existsSync(join(cwd, '.continue'))) {
+        detected.push('continue');
+    }
     // Suggest based on what's detected
     let suggested = null;
     if (detected.length === 1) {
@@ -57,7 +63,7 @@ export function getAITypeDescription(aiType) {
         case 'windsurf':
             return 'Windsurf (.windsurf/workflows/)';
         case 'antigravity':
-            return 'Antigravity (.agent/workflows/)';
+            return 'Antigravity / Generic Agent (.agent/skills/)';
         case 'copilot':
             return 'GitHub Copilot (.github/prompts/)';
         case 'kiro':
@@ -74,6 +80,10 @@ export function getAITypeDescription(aiType) {
             return 'CodeBuddy (.codebuddy/commands/)';
         case 'trae':
             return 'Trae (.trae/skills/)';
+        case 'opencode':
+            return 'OpenCode (.opencode/skills/)';
+        case 'continue':
+            return 'Continue (.continue/skills/)';
         case 'all':
             return 'All AI assistants';
     }

package/dist/utils/extract.d.ts

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

package/dist/utils/github.d.ts

@@ -0,0 +1,11 @@
+import type { Release } from '../types/index.js';
+export declare class GitHubRateLimitError extends Error {
+    constructor(message: string);
+}
+export declare class GitHubDownloadError extends Error {
+    constructor(message: string);
+}
+export declare function fetchReleases(): Promise<Release[]>;
+export declare function getLatestRelease(): Promise<Release>;
+export declare function downloadRelease(url: string, dest: string): Promise<void>;
+export declare function getAssetUrl(release: Release): string | null;

package/dist/utils/github.js

@@ -0,0 +1,81 @@
+import { writeFile } from 'node:fs/promises';
+const REPO_OWNER = 'nextlevelbuilder';
+const REPO_NAME = 'flutter-pro-max-skill';
+const API_BASE = 'https://api.github.com';
+export class GitHubRateLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitHubRateLimitError';
+    }
+}
+export class GitHubDownloadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitHubDownloadError';
+    }
+}
+function checkRateLimit(response) {
+    const remaining = response.headers.get('x-ratelimit-remaining');
+    if (response.status === 403 && remaining === '0') {
+        const resetTime = response.headers.get('x-ratelimit-reset');
+        const resetDate = resetTime ? new Date(parseInt(resetTime) * 1000).toLocaleTimeString() : 'unknown';
+        throw new GitHubRateLimitError(`GitHub API rate limit exceeded. Resets at ${resetDate}`);
+    }
+    if (response.status === 429) {
+        throw new GitHubRateLimitError('GitHub API rate limit exceeded (429 Too Many Requests)');
+    }
+}
+export async function fetchReleases() {
+    const url = `${API_BASE}/repos/${REPO_OWNER}/${REPO_NAME}/releases`;
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'flutter-pro-max-cli',
+        },
+    });
+    checkRateLimit(response);
+    if (!response.ok) {
+        throw new GitHubDownloadError(`Failed to fetch releases: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function getLatestRelease() {
+    const url = `${API_BASE}/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest`;
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': 'flutter-pro-max-cli',
+        },
+    });
+    checkRateLimit(response);
+    if (!response.ok) {
+        throw new GitHubDownloadError(`Failed to fetch latest release: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function downloadRelease(url, dest) {
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'flutter-pro-max-cli',
+            'Accept': 'application/octet-stream',
+        },
+    });
+    checkRateLimit(response);
+    if (!response.ok) {
+        throw new GitHubDownloadError(`Failed to download: ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    await writeFile(dest, Buffer.from(buffer));
+}
+export function getAssetUrl(release) {
+    // First try to find an uploaded ZIP asset
+    const asset = release.assets.find(a => a.name.endsWith('.zip'));
+    if (asset?.browser_download_url) {
+        return asset.browser_download_url;
+    }
+    // Fall back to GitHub's auto-generated archive
+    if (release.tag_name) {
+        return `https://github.com/${REPO_OWNER}/${REPO_NAME}/archive/refs/tags/${release.tag_name}.zip`;
+    }
+    return null;
+}

package/dist/utils/template.d.ts

@@ -0,0 +1,25 @@
+import type { PlatformConfig } from '../types/index.js';
+/**
+ * Load platform configuration from JSON file
+ */
+export declare function loadPlatformConfig(aiType: string): Promise<PlatformConfig>;
+/**
+ * Load all available platform configs
+ */
+export declare function loadAllPlatformConfigs(): Promise<Map<string, PlatformConfig>>;
+/**
+ * Render skill file content from template
+ */
+export declare function renderSkillFile(config: PlatformConfig): Promise<string>;
+/**
+ * Generate platform files for a specific AI type
+ */
+export declare function generatePlatformFiles(targetDir: string, aiType: string): Promise<string[]>;
+/**
+ * Generate files for all AI types
+ */
+export declare function generateAllPlatformFiles(targetDir: string): Promise<string[]>;
+/**
+ * Get list of supported AI types
+ */
+export declare function getSupportedAITypes(): string[];

package/dist/utils/template.js

@@ -0,0 +1,194 @@
+import { readFile, mkdir, writeFile, cp, access } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// After build: dist/utils/template.js -> ../../assets = cli/assets ✓
+const ASSETS_DIR = join(__dirname, '..', '..', 'assets');
+// Map AIType to platform config file name
+const AI_TO_PLATFORM = {
+    claude: 'claude',
+    cursor: 'cursor',
+    windsurf: 'windsurf',
+    antigravity: 'agent',
+    copilot: 'copilot',
+    kiro: 'kiro',
+    roocode: 'roocode',
+    codex: 'codex',
+    qoder: 'qoder',
+    gemini: 'gemini',
+    trae: 'trae',
+    codebuddy: 'codebuddy',
+    opencode: 'opencode',
+    continue: 'continue',
+};
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load platform configuration from JSON file
+ */
+export async function loadPlatformConfig(aiType) {
+    const platformName = AI_TO_PLATFORM[aiType];
+    if (!platformName) {
+        throw new Error(`Unknown AI type: ${aiType}`);
+    }
+    const configPath = join(ASSETS_DIR, 'templates', 'platforms', `${platformName}.json`);
+    const content = await readFile(configPath, 'utf-8');
+    return JSON.parse(content);
+}
+/**
+ * Load all available platform configs
+ */
+export async function loadAllPlatformConfigs() {
+    const configs = new Map();
+    for (const [aiType, platformName] of Object.entries(AI_TO_PLATFORM)) {
+        try {
+            const config = await loadPlatformConfig(aiType);
+            configs.set(aiType, config);
+        }
+        catch {
+            // Skip if config doesn't exist
+        }
+    }
+    return configs;
+}
+/**
+ * Load a template file
+ */
+async function loadTemplate(templateName) {
+    const templatePath = join(ASSETS_DIR, 'templates', templateName);
+    return readFile(templatePath, 'utf-8');
+}
+/**
+ * Render frontmatter section
+ */
+function renderFrontmatter(frontmatter) {
+    if (!frontmatter)
+        return '';
+    const lines = ['---'];
+    for (const [key, value] of Object.entries(frontmatter)) {
+        // Quote values that contain special characters
+        if (value.includes(':') || value.includes('"') || value.includes('\n')) {
+            lines.push(`${key}: "${value.replace(/"/g, '\\"')}"`);
+        }
+        else {
+            lines.push(`${key}: ${value}`);
+        }
+    }
+    lines.push('---', '');
+    return lines.join('\n');
+}
+/**
+ * Render skill file content from template
+ */
+export async function renderSkillFile(config) {
+    // Load base template
+    let content = await loadTemplate('base/skill-content.md');
+    // Load quick reference if needed
+    let quickReferenceContent = '';
+    if (config.sections.quickReference) {
+        quickReferenceContent = await loadTemplate('base/quick-reference.md');
+        // Replace script path in quick reference
+        quickReferenceContent = quickReferenceContent.replace(/\{\{SCRIPT_PATH\}\}/g, config.scriptPath);
+    }
+    // Build the final content
+    const frontmatter = renderFrontmatter(config.frontmatter);
+    // Replace placeholders
+    const quickRefWithNewline = quickReferenceContent ? '\n' + quickReferenceContent : '';
+    content = content
+        .replace(/\{\{TITLE\}\}/g, config.title)
+        .replace(/\{\{DESCRIPTION\}\}/g, config.description)
+        .replace(/\{\{SCRIPT_PATH\}\}/g, config.scriptPath)
+        .replace(/\{\{SKILL_OR_WORKFLOW\}\}/g, config.skillOrWorkflow)
+        .replace(/\{\{QUICK_REFERENCE\}\}/g, quickRefWithNewline);
+    return frontmatter + content;
+}
+/**
+ * Copy data and scripts to target directory
+ */
+async function copyDataAndScripts(targetSkillDir) {
+    const dataSource = join(ASSETS_DIR, 'data');
+    const scriptsSource = join(ASSETS_DIR, 'scripts');
+    const dataTarget = join(targetSkillDir, 'data');
+    const scriptsTarget = join(targetSkillDir, 'scripts');
+    // Copy data
+    if (await exists(dataSource)) {
+        await mkdir(dataTarget, { recursive: true });
+        await cp(dataSource, dataTarget, { recursive: true });
+    }
+    // Copy scripts
+    if (await exists(scriptsSource)) {
+        await mkdir(scriptsTarget, { recursive: true });
+        await cp(scriptsSource, scriptsTarget, { recursive: true });
+    }
+}
+/**
+ * Ensure .shared folder exists with data and scripts
+ */
+async function ensureSharedExists(targetDir) {
+    const sharedDir = join(targetDir, '.shared', 'flutter-pro-max');
+    // Check if already exists
+    if (await exists(sharedDir)) {
+        return false; // Already exists, didn't create
+    }
+    await mkdir(sharedDir, { recursive: true });
+    await copyDataAndScripts(sharedDir);
+    return true; // Created new
+}
+/**
+ * Generate platform files for a specific AI type
+ */
+export async function generatePlatformFiles(targetDir, aiType) {
+    const config = await loadPlatformConfig(aiType);
+    const createdFolders = [];
+    // Determine full skill directory path
+    const skillDir = join(targetDir, config.folderStructure.root, config.folderStructure.skillPath);
+    // Create directory structure
+    await mkdir(skillDir, { recursive: true });
+    // Render and write skill file
+    const skillContent = await renderSkillFile(config);
+    const skillFilePath = join(skillDir, config.folderStructure.filename);
+    await writeFile(skillFilePath, skillContent, 'utf-8');
+    createdFolders.push(config.folderStructure.root);
+    // Handle data/scripts based on install type
+    if (config.installType === 'full') {
+        // Full install: copy data and scripts into the skill directory
+        await copyDataAndScripts(skillDir);
+    }
+    else {
+        // Reference install: ensure .shared exists
+        const createdShared = await ensureSharedExists(targetDir);
+        if (createdShared) {
+            createdFolders.push('.shared');
+        }
+    }
+    return createdFolders;
+}
+/**
+ * Generate files for all AI types
+ */
+export async function generateAllPlatformFiles(targetDir) {
+    const allFolders = new Set();
+    for (const aiType of Object.keys(AI_TO_PLATFORM)) {
+        try {
+            const folders = await generatePlatformFiles(targetDir, aiType);
+            folders.forEach(f => allFolders.add(f));
+        }
+        catch {
+            // Skip if generation fails for a platform
+        }
+    }
+    return Array.from(allFolders);
+}
+/**
+ * Get list of supported AI types
+ */
+export function getSupportedAITypes() {
+    return Object.keys(AI_TO_PLATFORM);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "flutter-pro-max-cli",
-    "version": "1.0.2",
+    "version": "2.1.0",
     "description": "CLI to install Flutter Pro Max skill for AI coding assistants",
     "type": "module",
     "bin": {
@@ -12,9 +12,8 @@
         "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",
+        "build": "tsc",
+        "build:bun": "bun build src/index.ts --outdir dist --target node",
         "dev": "npx ts-node --esm src/index.ts",
         "prepublishOnly": "npm run build"
     },
@@ -32,6 +31,11 @@
         "roocode",
         "codex",
         "qoder",
+        "gemini",
+        "opencode",
+        "continue",
+        "codebuddy",
+        "trae",
         "ai",
         "skill"
     ],