figmanage 1.1.0 → 1.2.0

package/dist/cli/completion.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+/**
+ * Create the `completion` command. Needs the parent program reference
+ * so it can introspect the full command tree at runtime.
+ */
+export declare function completionCommand(program: Command): Command;
+//# sourceMappingURL=completion.d.ts.map

package/dist/cli/completion.js

@@ -0,0 +1,160 @@
+import { Command } from 'commander';
+/**
+ * Introspect a Commander program and extract its command tree.
+ * Returns a map of command names to their subcommand names.
+ * Top-level commands without subcommands (like login, whoami) get an empty array.
+ */
+function extractCommandTree(program) {
+    const tree = new Map();
+    for (const cmd of program.commands) {
+        const subs = cmd.commands.map((sub) => sub.name());
+        tree.set(cmd.name(), subs);
+    }
+    return tree;
+}
+/**
+ * Extract all option flags from a command (including inherited ones).
+ * Returns long-form flags like --json, --help.
+ */
+function extractOptions(cmd) {
+    const flags = [];
+    for (const opt of cmd.options) {
+        if (opt.long)
+            flags.push(opt.long);
+    }
+    return flags;
+}
+/**
+ * Collect global options that appear across most commands.
+ * These get offered at every completion point.
+ */
+function extractGlobalOptions(program) {
+    const flags = new Set();
+    // Program-level options (--version, etc.)
+    for (const opt of program.options) {
+        if (opt.long)
+            flags.add(opt.long);
+    }
+    // Common flags present on subcommands
+    flags.add('--help');
+    flags.add('--json');
+    return [...flags];
+}
+function generateZshScript(program) {
+    const tree = extractCommandTree(program);
+    const globalOpts = extractGlobalOptions(program);
+    const topLevelCmds = [...tree.keys()];
+    // Build case arms for subcommand completion
+    const caseArms = [];
+    for (const [group, subs] of tree) {
+        if (subs.length > 0) {
+            caseArms.push(`      ${group})\n        local subcmds=(${subs.join(' ')})\n        _describe 'subcommand' subcmds\n        ;;`);
+        }
+    }
+    return `#compdef figmanage
+
+# Shell completion for figmanage
+# Add to ~/.zshrc: eval "$(figmanage completion)"
+
+_figmanage() {
+  local -a commands
+  commands=(${topLevelCmds.join(' ')})
+
+  local global_opts=(${globalOpts.join(' ')})
+
+  _arguments -C \\
+    '1:command:->cmd' \\
+    '2:subcommand:->sub' \\
+    '*::options:->opts'
+
+  case $state in
+    cmd)
+      _describe 'command' commands
+      ;;
+    sub)
+      case $words[1] in
+${caseArms.join('\n')}
+      *)
+        _describe 'option' global_opts
+        ;;
+      esac
+      ;;
+    opts)
+      _values 'options' $global_opts
+      ;;
+  esac
+}
+
+compdef _figmanage figmanage
+`;
+}
+function generateBashScript(program) {
+    const tree = extractCommandTree(program);
+    const globalOpts = extractGlobalOptions(program);
+    const topLevelCmds = [...tree.keys()];
+    // Build case arms for subcommand completion
+    const caseArms = [];
+    for (const [group, subs] of tree) {
+        if (subs.length > 0) {
+            caseArms.push(`      ${group})\n        COMPREPLY=($(compgen -W "${subs.join(' ')}" -- "$cur"))\n        ;;`);
+        }
+    }
+    return `# Shell completion for figmanage
+# Add to ~/.bashrc: eval "$(figmanage completion)"
+
+_figmanage() {
+  local cur prev words cword
+  _init_completion || return
+
+  local commands="${topLevelCmds.join(' ')}"
+  local global_opts="${globalOpts.join(' ')}"
+
+  case $cword in
+    1)
+      COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+      ;;
+    2)
+      case "\${words[1]}" in
+${caseArms.join('\n')}
+      *)
+        COMPREPLY=($(compgen -W "$global_opts" -- "$cur"))
+        ;;
+      esac
+      ;;
+    *)
+      COMPREPLY=($(compgen -W "$global_opts" -- "$cur"))
+      ;;
+  esac
+}
+
+complete -F _figmanage figmanage
+`;
+}
+function detectShell() {
+    const shell = process.env.SHELL ?? '';
+    if (shell.endsWith('/zsh'))
+        return 'zsh';
+    return 'bash';
+}
+/**
+ * Create the `completion` command. Needs the parent program reference
+ * so it can introspect the full command tree at runtime.
+ */
+export function completionCommand(program) {
+    const cmd = new Command('completion')
+        .description('Output shell completion script')
+        .option('--shell <shell>', 'Shell type (bash or zsh)')
+        .action((options) => {
+        const shell = options.shell ?? detectShell();
+        if (shell !== 'bash' && shell !== 'zsh') {
+            console.error(`Unsupported shell: ${shell}. Use --shell bash or --shell zsh.`);
+            process.exit(1);
+        }
+        const script = shell === 'zsh'
+            ? generateZshScript(program)
+            : generateBashScript(program);
+        process.stdout.write(script);
+    });
+    return cmd;
+}
+//# sourceMappingURL=completion.js.map

package/dist/cli/format.js

@@ -2,13 +2,158 @@
 export function isTTY() {
     return process.stdout.isTTY === true;
 }
+/** Get terminal width, defaulting to 80 if unavailable */
+function termWidth() {
+    return process.stdout.columns || 80;
+}
+/** Format a value for display in a table cell */
+function formatCell(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.length} items]`;
+    if (typeof value === 'object')
+        return '{...}';
+    return String(value);
+}
+/** Truncate a string to maxLen, appending ... if truncated */
+function truncate(str, maxLen) {
+    if (maxLen < 4)
+        return str.slice(0, maxLen);
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + '...';
+}
+/** Pad a string to the right with spaces */
+function padRight(str, width) {
+    if (str.length >= width)
+        return str;
+    return str + ' '.repeat(width - str.length);
+}
+/**
+ * Render an array of objects as an aligned table.
+ * Columns are auto-sized to content, then shrunk proportionally if they
+ * exceed terminal width. A minimum gap of 2 spaces separates columns.
+ */
+function formatTable(rows) {
+    if (rows.length === 0)
+        return '';
+    // Collect all keys across all rows (preserving insertion order)
+    const keySet = new Set();
+    for (const row of rows) {
+        for (const key of Object.keys(row)) {
+            keySet.add(key);
+        }
+    }
+    const keys = Array.from(keySet);
+    // Build string grid: headers + data
+    const headers = keys.map((k) => k.toUpperCase());
+    const grid = rows.map((row) => keys.map((k) => formatCell(row[k])));
+    // Compute natural column widths (max of header and all data cells)
+    const colWidths = keys.map((_, i) => {
+        let max = headers[i].length;
+        for (const row of grid) {
+            if (row[i].length > max)
+                max = row[i].length;
+        }
+        return max;
+    });
+    const gap = 2;
+    const maxWidth = termWidth();
+    const totalGap = gap * (keys.length - 1);
+    const totalNatural = colWidths.reduce((a, b) => a + b, 0) + totalGap;
+    // If columns exceed terminal width, shrink the widest columns first
+    if (totalNatural > maxWidth && keys.length > 0) {
+        const budget = maxWidth - totalGap;
+        if (budget > 0) {
+            // Give each column at least 4 chars, distribute remaining proportionally
+            const minCol = 4;
+            const guaranteed = Math.min(minCol, Math.floor(budget / keys.length));
+            let remaining = budget;
+            // First pass: cap each column to its natural width or proportional share
+            const totalContent = colWidths.reduce((a, b) => a + b, 0);
+            for (let i = 0; i < colWidths.length; i++) {
+                const share = Math.max(guaranteed, Math.floor((colWidths[i] / totalContent) * budget));
+                colWidths[i] = Math.min(colWidths[i], share);
+                remaining -= colWidths[i];
+            }
+            // Distribute leftover to columns that were truncated
+            if (remaining > 0) {
+                for (let i = 0; i < colWidths.length && remaining > 0; i++) {
+                    const natural = headers[i].length;
+                    const canGrow = Math.max(0, natural - colWidths[i]);
+                    const give = Math.min(canGrow, remaining);
+                    colWidths[i] += give;
+                    remaining -= give;
+                }
+            }
+        }
+    }
+    // Render rows
+    const lines = [];
+    // Header row
+    const headerLine = keys
+        .map((_, i) => padRight(truncate(headers[i], colWidths[i]), colWidths[i]))
+        .join(' '.repeat(gap));
+    lines.push(headerLine.trimEnd());
+    // Data rows
+    for (const row of grid) {
+        const line = keys
+            .map((_, i) => padRight(truncate(row[i], colWidths[i]), colWidths[i]))
+            .join(' '.repeat(gap));
+        lines.push(line.trimEnd());
+    }
+    return lines.join('\n');
+}
+/**
+ * Render a single object as key-value pairs.
+ * Falls back to JSON for deeply nested objects.
+ */
+function formatKeyValue(obj) {
+    // If every value is a nested object/array, this won't be readable as k/v.
+    // Check if the majority of values are complex -- if so, fall back to JSON.
+    const values = Object.values(obj);
+    const complexCount = values.filter((v) => v !== null && typeof v === 'object').length;
+    if (complexCount > values.length / 2) {
+        return JSON.stringify(obj, null, 2);
+    }
+    const entries = Object.entries(obj);
+    if (entries.length === 0)
+        return '{}';
+    return entries.map(([key, val]) => `${key}: ${formatCell(val)}`).join('\n');
+}
 /** Format output: JSON if piped or --json flag, human-readable if TTY */
 export function formatOutput(data, options) {
     if (options.json || !isTTY()) {
         return JSON.stringify(data, null, 2);
     }
-    // Table formatting will be added later; fall back to JSON for now
-    return JSON.stringify(data, null, 2);
+    // Primitives: render as-is
+    if (data === null || data === undefined)
+        return '';
+    if (typeof data === 'string')
+        return data;
+    if (typeof data === 'number' || typeof data === 'boolean')
+        return String(data);
+    // Array of objects: table
+    if (Array.isArray(data)) {
+        if (data.length === 0)
+            return '';
+        // If every element is a plain object, render as table
+        if (data.every((item) => item !== null && typeof item === 'object' && !Array.isArray(item))) {
+            return formatTable(data);
+        }
+        // Array of primitives or mixed: one per line
+        return data.map((item) => formatCell(item)).join('\n');
+    }
+    // Single object
+    if (typeof data === 'object') {
+        return formatKeyValue(data);
+    }
+    return String(data);
 }
 /** Print formatted output to stdout */
 export function output(data, options = {}) {

package/dist/cli/index.js

@@ -14,6 +14,7 @@ import { analyticsCommand } from './analytics.js';
 import { orgCommand } from './org.js';
 import { librariesCommand } from './libraries.js';
 import { teamsCommand } from './teams.js';
+import { completionCommand } from './completion.js';
 import { fileSummaryCommand, workspaceOverviewCommand, openCommentsCommand, cleanupStaleFilesCommand, organizeProjectCommand, setupProjectStructureCommand, seatOptimizationCommand, permissionAuditCommand, branchCleanupCommand, offboardUserCommand, onboardUserCommand, quarterlyReportCommand, } from './compound-commands.js';
 export function registerCliCommands(program) {
     // Auth commands (flat -- not resource-scoped)
@@ -87,5 +88,7 @@ export function registerCliCommands(program) {
     program.addCommand(org);
     program.addCommand(libraries);
     program.addCommand(teams);
+    // Completion must be registered last so it can introspect all commands above
+    program.addCommand(completionCommand(program));
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "figmanage",
   "mcpName": "io.github.dannykeane/figmanage",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "MCP server for managing your Figma workspace from the terminal.",
   "type": "module",
   "main": "dist/index.js",