fscr 6.2.3 → 7.3.0

package/dist/lib/completions/completion.js

@@ -0,0 +1,342 @@
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import os from "os";
+import { execSync } from "child_process";
+import inquirer from "inquirer";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Detect the user's current shell
+ */
+export function detectShell() {
+    // Check SHELL environment variable
+    const shellEnv = process.env.SHELL;
+    if (shellEnv) {
+        const shellName = path.basename(shellEnv);
+        if (["bash", "zsh", "fish"].includes(shellName)) {
+            return shellName;
+        }
+    }
+
+    // Check for PowerShell on Windows
+    if (process.platform === "win32") {
+        return "powershell";
+    }
+
+    // Default to bash if unable to detect
+    return "bash";
+}
+
+/**
+ * Get shell configuration file path
+ */
+export function getShellConfigPath(shell) {
+    const homeDir = os.homedir();
+
+    const configPaths = {
+        bash: path.join(homeDir, ".bashrc"),
+        zsh: path.join(homeDir, ".zshrc"),
+        fish: path.join(homeDir, ".config", "fish", "config.fish"),
+        powershell: path.join(
+            homeDir,
+            "Documents",
+            "WindowsPowerShell",
+            "Microsoft.PowerShell_profile.ps1"
+        )
+    };
+
+    return configPaths[shell] || configPaths.bash;
+}
+
+/**
+ * Get the completion script path for a shell
+ */
+export function getCompletionScriptPath(shell) {
+    const scriptsDir = path.join(__dirname, "scripts");
+    const scriptFiles = {
+        bash: path.join(scriptsDir, "bash.sh"),
+        zsh: path.join(scriptsDir, "zsh.sh"),
+        fish: path.join(scriptsDir, "fish.sh"),
+        powershell: path.join(scriptsDir, "powershell.ps1")
+    };
+
+    return scriptFiles[shell];
+}
+
+/**
+ * Install completion script for a specific shell
+ */
+export async function installCompletion(shell, options = {}) {
+    const { force = false, silent = false } = options;
+
+    try {
+        const configPath = getShellConfigPath(shell);
+        const scriptPath = getCompletionScriptPath(shell);
+
+        // Check if script exists
+        if (!fs.existsSync(scriptPath)) {
+            throw new Error(`Completion script not found for ${shell}`);
+        }
+
+        // Read the completion script
+        const completionScript = fs.readFileSync(scriptPath, "utf8");
+
+        // For fish, create completions directory
+        if (shell === "fish") {
+            const fishCompDir = path.join(os.homedir(), ".config", "fish", "completions");
+            await fs.ensureDir(fishCompDir);
+
+            const fishCompPath = path.join(fishCompDir, "fsr.fish");
+            await fs.writeFile(fishCompPath, completionScript);
+
+            if (!silent) {
+                console.log(chalk.green("✅ Installed Fish completions to"), fishCompPath);
+            }
+            return fishCompPath;
+        }
+
+        // For other shells, append to config file
+        await fs.ensureFile(configPath);
+        const currentConfig = await fs.readFile(configPath, "utf8");
+
+        // Check if already installed
+        const marker = "# FSCR completion";
+        if (currentConfig.includes(marker) && !force) {
+            if (!silent) {
+                console.log(chalk.yellow("⚠️  Completions already installed"));
+                console.log(chalk.dim(`   Use --force to reinstall`));
+            }
+            return configPath;
+        }
+
+        // Prepare completion block
+        const completionBlock = `
+${marker}
+${completionScript}
+# End FSCR completion
+`;
+
+        // Append or replace completion block
+        let newConfig;
+        if (currentConfig.includes(marker)) {
+            // Replace existing block
+            newConfig = currentConfig.replace(
+                /# FSCR completion[\s\S]*?# End FSCR completion\n?/,
+                completionBlock
+            );
+        } else {
+            // Append new block
+            newConfig = currentConfig + "\n" + completionBlock;
+        }
+
+        await fs.writeFile(configPath, newConfig);
+
+        if (!silent) {
+            console.log(chalk.green("✅ Installed completions to"), configPath);
+        }
+
+        return configPath;
+    } catch (error) {
+        throw new Error(`Failed to install ${shell} completions: ${error.message}`);
+    }
+}
+
+/**
+ * Uninstall completion script
+ */
+export async function uninstallCompletion(shell, options = {}) {
+    const { silent = false } = options;
+
+    try {
+        const configPath = getShellConfigPath(shell);
+
+        if (shell === "fish") {
+            const fishCompPath = path.join(
+                os.homedir(),
+                ".config",
+                "fish",
+                "completions",
+                "fsr.fish"
+            );
+
+            if (fs.existsSync(fishCompPath)) {
+                await fs.remove(fishCompPath);
+                if (!silent) {
+                    console.log(chalk.green("✅ Removed Fish completions"));
+                }
+            } else {
+                if (!silent) {
+                    console.log(chalk.yellow("⚠️  No Fish completions found"));
+                }
+            }
+            return;
+        }
+
+        // For other shells, remove from config file
+        if (!fs.existsSync(configPath)) {
+            if (!silent) {
+                console.log(chalk.yellow(`⚠️  Config file not found: ${configPath}`));
+            }
+            return;
+        }
+
+        const currentConfig = await fs.readFile(configPath, "utf8");
+        const marker = "# FSCR completion";
+
+        if (!currentConfig.includes(marker)) {
+            if (!silent) {
+                console.log(chalk.yellow("⚠️  No completions found to uninstall"));
+            }
+            return;
+        }
+
+        // Remove completion block
+        const newConfig = currentConfig.replace(
+            /# FSCR completion[\s\S]*?# End FSCR completion\n?/,
+            ""
+        );
+
+        await fs.writeFile(configPath, newConfig);
+
+        if (!silent) {
+            console.log(chalk.green("✅ Removed completions from"), configPath);
+        }
+    } catch (error) {
+        throw new Error(`Failed to uninstall ${shell} completions: ${error.message}`);
+    }
+}
+
+/**
+ * Show completion status for all shells
+ */
+export async function completionStatus() {
+    const shells = ["bash", "zsh", "fish", "powershell"];
+    const currentShell = detectShell();
+
+    console.log(chalk.bold("\n📋 Completion Status\n"));
+
+    for (const shell of shells) {
+        const isCurrent = shell === currentShell;
+        const marker = isCurrent ? chalk.green("●") : chalk.dim("○");
+
+        try {
+            const configPath = getShellConfigPath(shell);
+            let installed = false;
+
+            if (shell === "fish") {
+                const fishCompPath = path.join(
+                    os.homedir(),
+                    ".config",
+                    "fish",
+                    "completions",
+                    "fsr.fish"
+                );
+                installed = fs.existsSync(fishCompPath);
+            } else {
+                if (fs.existsSync(configPath)) {
+                    const config = await fs.readFile(configPath, "utf8");
+                    installed = config.includes("# FSCR completion");
+                }
+            }
+
+            const status = installed ? chalk.green("✅ Installed") : chalk.dim("Not installed");
+            const current = isCurrent ? chalk.yellow(" (current)") : "";
+
+            console.log(`${marker} ${chalk.bold(shell.padEnd(12))} ${status}${current}`);
+        } catch (error) {
+            console.log(`${marker} ${chalk.bold(shell.padEnd(12))} ${chalk.red("Error")}`);
+        }
+    }
+
+    console.log();
+}
+
+/**
+ * Main completion command handler
+ */
+export default async function completion(argv) {
+    // Get the action from positional argument or from argv._[1]
+    const command = argv.action || argv._[1];
+    const shell = argv.shell || detectShell();
+
+    try {
+        switch (command) {
+            case "install":
+                await installCompletion(shell, { force: argv.force });
+                console.log();
+                console.log(chalk.cyan("🎉 Completions installed successfully!"));
+                console.log();
+                console.log(chalk.dim("To activate completions, restart your shell or run:"));
+                console.log(
+                    chalk.yellow(
+                        shell === "fish"
+                            ? "  exec fish"
+                            : shell === "powershell"
+                              ? "  . $PROFILE"
+                              : `  source ${getShellConfigPath(shell)}`
+                    )
+                );
+                console.log();
+                break;
+
+            case "uninstall":
+                await uninstallCompletion(shell);
+                console.log();
+                console.log(chalk.cyan("✅ Completions uninstalled successfully!"));
+                console.log();
+                break;
+
+            case "status":
+                await completionStatus();
+                break;
+
+            case "generate":
+                // Generate completion script without installing
+                const scriptPath = getCompletionScriptPath(shell);
+                if (!fs.existsSync(scriptPath)) {
+                    throw new Error(`Completion script not found for ${shell}`);
+                }
+                const script = fs.readFileSync(scriptPath, "utf8");
+                console.log(script);
+                break;
+
+            default:
+                // Interactive installation
+                const { confirmInstall } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirmInstall",
+                        message: `Install completions for ${chalk.cyan(shell)}?`,
+                        default: true
+                    }
+                ]);
+
+                if (confirmInstall) {
+                    await installCompletion(shell, { force: argv.force });
+                    console.log();
+                    console.log(chalk.cyan("🎉 Completions installed successfully!"));
+                    console.log();
+                    console.log(chalk.dim("To activate completions, restart your shell or run:"));
+                    console.log(
+                        chalk.yellow(
+                            shell === "fish"
+                                ? "  exec fish"
+                                : shell === "powershell"
+                                  ? "  . $PROFILE"
+                                  : `  source ${getShellConfigPath(shell)}`
+                        )
+                    );
+                    console.log();
+                } else {
+                    console.log(chalk.yellow("Installation cancelled"));
+                }
+        }
+    } catch (error) {
+        console.error(chalk.red("Error:"), error.message);
+        process.exit(1);
+    }
+}

package/dist/lib/completions/generator.js

@@ -0,0 +1,152 @@
+import fs from "fs-extra";
+import path from "path";
+import parseScriptFile from "../parsers/parseScriptsMd.js";
+
+/**
+ * Cache for parsed tasks to avoid re-parsing on every completion
+ */
+let taskCache = null;
+let cacheTime = 0;
+const CACHE_TTL = 5000; // 5 seconds
+
+/**
+ * Get all available tasks from fscripts.md with caching
+ */
+export async function getAvailableTasks(forceRefresh = false) {
+    const now = Date.now();
+
+    // Return cached tasks if still valid
+    if (!forceRefresh && taskCache && now - cacheTime < CACHE_TTL) {
+        return taskCache;
+    }
+
+    try {
+        const { allTasks } = await parseScriptFile();
+        taskCache = allTasks.map((task) => ({
+            name: task.name,
+            description: task.description || "",
+            lang: task.lang || "bash"
+        }));
+        cacheTime = now;
+        return taskCache;
+    } catch (error) {
+        // If parsing fails, return empty array
+        return [];
+    }
+}
+
+/**
+ * Get all available commands
+ */
+export function getAvailableCommands() {
+    return [
+        { name: "start", description: "Choose category then task to run" },
+        { name: "run", description: "Run a specific task" },
+        { name: "list", description: "Select any task with text autocompletion" },
+        { name: "scripts", description: "Choose a script from package.json" },
+        { name: "run-s", description: "Run tasks in sequence" },
+        { name: "run-p", description: "Run tasks in parallel" },
+        { name: "bump", description: "Bump package.json version" },
+        { name: "upgrade", description: "Upgrade packages" },
+        { name: "branch", description: "Create new branch" },
+        { name: "remote", description: "Get remote configuration" },
+        { name: "encryption", description: "Encrypt/Decrypt files" },
+        { name: "clear", description: "Clear recent task history" },
+        { name: "generate", description: "Generate sample fscripts.md" },
+        { name: "toc", description: "Generate table of contents" },
+        { name: "completion", description: "Manage shell completions" }
+    ];
+}
+
+/**
+ * Get completion subcommands
+ */
+export function getCompletionSubcommands() {
+    return [
+        { name: "install", description: "Install completions" },
+        { name: "uninstall", description: "Uninstall completions" },
+        { name: "status", description: "Show completion status" },
+        { name: "generate", description: "Generate completion script" }
+    ];
+}
+
+/**
+ * Generate task names for shell completion
+ */
+export async function generateTaskNames() {
+    const tasks = await getAvailableTasks();
+    return tasks.map((t) => t.name);
+}
+
+/**
+ * Generate bash completion data
+ */
+export async function generateBashCompletionData() {
+    const tasks = await getAvailableTasks();
+    const commands = getAvailableCommands();
+    const completionCmds = getCompletionSubcommands();
+
+    return {
+        commands: commands.map((c) => c.name),
+        tasks: tasks.map((t) => t.name),
+        completionSubcommands: completionCmds.map((c) => c.name)
+    };
+}
+
+/**
+ * Generate zsh completion data
+ */
+export async function generateZshCompletionData() {
+    const tasks = await getAvailableTasks();
+    const commands = getAvailableCommands();
+    const completionCmds = getCompletionSubcommands();
+
+    return {
+        commands: commands.map((c) => `${c.name}:${c.description}`),
+        tasks: tasks.map((t) => {
+            const desc = t.description.replace(/[:\n]/g, " ").trim();
+            return `${t.name}:${desc || "Run task"}`;
+        }),
+        completionSubcommands: completionCmds.map((c) => `${c.name}:${c.description}`)
+    };
+}
+
+/**
+ * Generate fish completion data
+ */
+export async function generateFishCompletionData() {
+    const tasks = await getAvailableTasks();
+    const commands = getAvailableCommands();
+    const completionCmds = getCompletionSubcommands();
+
+    return {
+        commands: commands.map((c) => ({
+            name: c.name,
+            description: c.description
+        })),
+        tasks: tasks.map((t) => ({
+            name: t.name,
+            description: t.description || "Run task"
+        })),
+        completionSubcommands: completionCmds.map((c) => ({
+            name: c.name,
+            description: c.description
+        }))
+    };
+}
+
+/**
+ * Export tasks for completion (used by shell scripts)
+ */
+export async function exportTasksForCompletion() {
+    const tasks = await getAvailableTasks();
+    return tasks.map((t) => t.name).join("\n");
+}
+
+/**
+ * Clear the task cache (useful when fscripts.md is updated)
+ */
+export function clearTaskCache() {
+    taskCache = null;
+    cacheTime = 0;
+}

package/dist/lib/completions/scripts/bash.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# FSCR Bash completion script
+
+_fscr_get_tasks() {
+    # Try to get tasks from fscripts.md
+    if command -v node >/dev/null 2>&1; then
+        local tasks_output
+        tasks_output=$(node -e "
+            import('$FSCR_COMPLETION_HELPER').then(async (m) => {
+                const tasks = await m.generateTaskNames();
+                console.log(tasks.join(' '));
+            }).catch(() => {});
+        " 2>/dev/null)
+
+        if [ -n "$tasks_output" ]; then
+            echo "$tasks_output"
+            return
+        fi
+    fi
+
+    # Fallback: parse fscripts.md directly
+    if [ -f "fscripts.md" ]; then
+        grep -E "^## " fscripts.md | sed 's/^## //' | tr '\n' ' '
+    fi
+}
+
+_fscr_completion() {
+    local cur prev words cword
+    _init_completion || return
+
+    # Main commands
+    local commands="start run list scripts run-s run-p bump upgrade branch remote encryption clear generate toc completion"
+
+    # Completion subcommands
+    local completion_cmds="install uninstall status generate"
+
+    # Get current word and previous word
+    local cur="${COMP_WORDS[COMP_CWORD]}"
+    local prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+    # Get the main command (first argument after fsr)
+    local cmd=""
+    if [ ${COMP_CWORD} -gt 0 ]; then
+        cmd="${COMP_WORDS[1]}"
+    fi
+
+    case "${prev}" in
+        fsr|fsr)
+            # Complete main commands
+            COMPREPLY=($(compgen -W "${commands}" -- "${cur}"))
+            return 0
+            ;;
+        run|run-s|run-p)
+            # Complete task names
+            local tasks=$(_fscr_get_tasks)
+            COMPREPLY=($(compgen -W "${tasks}" -- "${cur}"))
+            return 0
+            ;;
+        completion)
+            # Complete completion subcommands
+            COMPREPLY=($(compgen -W "${completion_cmds}" -- "${cur}"))
+            return 0
+            ;;
+        install|uninstall)
+            # Complete shell names
+            if [ "${cmd}" = "completion" ]; then
+                COMPREPLY=($(compgen -W "bash zsh fish powershell" -- "${cur}"))
+                return 0
+            fi
+            ;;
+        --shell)
+            # Complete shell names for --shell flag
+            COMPREPLY=($(compgen -W "bash zsh fish powershell" -- "${cur}"))
+            return 0
+            ;;
+    esac
+
+    # Handle flags
+    case "${cur}" in
+        -*)
+            case "${cmd}" in
+                completion)
+                    COMPREPLY=($(compgen -W "--shell --force --help" -- "${cur}"))
+                    ;;
+                run)
+                    COMPREPLY=($(compgen -W "--help" -- "${cur}"))
+                    ;;
+                *)
+                    COMPREPLY=($(compgen -W "--help" -- "${cur}"))
+                    ;;
+            esac
+            return 0
+            ;;
+    esac
+
+    # Continue completing task names for run-s and run-p
+    if [ "${cmd}" = "run-s" ] || [ "${cmd}" = "run-p" ]; then
+        local tasks=$(_fscr_get_tasks)
+        COMPREPLY=($(compgen -W "${tasks}" -- "${cur}"))
+        return 0
+    fi
+
+    return 0
+}
+
+# Register completion for both fsr and fsr
+complete -F _fscr_completion fsr
+complete -F _fscr_completion fsr