tsoft-cli 3.12.3 → 3.13.0

package/src/ui/command-suggestion.js

@@ -0,0 +1,78 @@
+import { t } from '../i18n.js';
+
+const MAX_DISTANCE = 3;
+
+function editDistance(a, b) {
+    if (Math.abs(a.length - b.length) > MAX_DISTANCE) {
+        return Math.max(a.length, b.length);
+    }
+
+    const d = [];
+
+    for (let i = 0; i <= a.length; i++) {
+        d[i] = [i];
+    }
+    for (let j = 0; j <= b.length; j++) {
+        d[0][j] = j;
+    }
+
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+
+            d[i][j] = Math.min(
+                d[i - 1][j] + 1,
+                d[i][j - 1] + 1,
+                d[i - 1][j - 1] + cost
+            );
+
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+            }
+        }
+    }
+
+    return d[a.length][b.length];
+}
+
+export function suggestCommand(word, candidates) {
+    const typed = word.toLowerCase();
+    let best = null;
+    let bestDistance = MAX_DISTANCE + 1;
+
+    for (const candidate of candidates) {
+        const name = candidate.toLowerCase();
+
+        if (name === typed) {
+            return null;
+        }
+
+        const isPrefix = name.startsWith(typed) && typed.length > 0;
+        const distance = isPrefix ? 0 : editDistance(typed, name);
+
+        if (distance <= MAX_DISTANCE && distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+
+    return best;
+}
+
+export function formatUnknownCommand(word, candidates, parentPath = null) {
+    const suggestion = suggestCommand(word, candidates);
+    const lines = [
+        parentPath
+            ? t('error.unknown_subcommand', { parent: parentPath, command: word })
+            : t('error.unknown_command', { command: word }),
+    ];
+
+    if (suggestion) {
+        const full = parentPath ? `${parentPath} ${suggestion}` : suggestion;
+        lines.push('', t('error.did_you_mean', { suggestion: full }));
+    } else {
+        lines.push('', t('error.see_help'));
+    }
+
+    return lines.join('\n');
+}

package/src/ui/completion.js

@@ -0,0 +1,189 @@
+export const SUPPORTED_SHELLS = ['bash', 'zsh', 'fish'];
+
+export function collectCommandTree(command) {
+    const children = [];
+
+    for (const sub of command.commands) {
+        if (sub._hidden) {
+            continue;
+        }
+
+        children.push({
+            name: sub.name(),
+            aliases: sub.aliases().filter(Boolean),
+            description: sub.description() ?? '',
+            children: collectCommandTree(sub).children,
+        });
+    }
+
+    return { name: command.name(), children };
+}
+
+function flatten(tree) {
+    const paths = [];
+
+    const walk = (node, prefix) => {
+        for (const child of node.children) {
+            for (const name of [child.name, ...child.aliases]) {
+                const path = [...prefix, name];
+                paths.push({ path, description: child.description });
+            }
+            walk(child, [...prefix, child.name]);
+        }
+    };
+
+    walk(tree, []);
+
+    return paths;
+}
+
+function namesByParent(tree) {
+    const groups = new Map();
+
+    const walk = (node, prefix) => {
+        const key = prefix.join(' ');
+        const names = [];
+
+        for (const child of node.children) {
+            names.push(child.name, ...child.aliases);
+            walk(child, [...prefix, child.name]);
+        }
+
+        if (names.length) {
+            groups.set(key, names);
+        }
+    };
+
+    walk(tree, []);
+
+    return groups;
+}
+
+function renderBash(tree) {
+    const groups = namesByParent(tree);
+    const cases = [];
+
+    for (const [parent, names] of groups) {
+        const pattern = parent === '' ? '' : parent;
+        cases.push(`        "${pattern}") opts="${names.join(' ')}" ;;`);
+    }
+
+    return `# tsoft completion for bash
+# Install: tsoft completion bash > /etc/bash_completion.d/tsoft
+#      or: echo 'source <(tsoft completion bash)' >> ~/.bashrc
+
+_tsoft_completions() {
+    local cur words path opts
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    words=("\${COMP_WORDS[@]:1:COMP_CWORD-1}")
+    path=""
+
+    for word in "\${words[@]}"; do
+        case "$word" in
+            -*) continue ;;
+        esac
+        if [ -z "$path" ]; then path="$word"; else path="$path $word"; fi
+    done
+
+    case "$path" in
+${cases.join('\n')}
+        *) opts="" ;;
+    esac
+
+    if [ -z "$opts" ]; then
+        COMPREPLY=()
+        return 0
+    fi
+
+    COMPREPLY=($(compgen -W "$opts" -- "$cur"))
+    return 0
+}
+
+complete -F _tsoft_completions tsoft
+`;
+}
+
+function renderZsh(tree) {
+    const groups = namesByParent(tree);
+    const cases = [];
+
+    for (const [parent, names] of groups) {
+        cases.push(`        "${parent}") opts=(${names.join(' ')}) ;;`);
+    }
+
+    return `#compdef tsoft
+# tsoft completion for zsh
+# Install: tsoft completion zsh > "\${fpath[1]}/_tsoft"
+#      or: echo 'source <(tsoft completion zsh)' >> ~/.zshrc
+
+_tsoft() {
+    local -a opts
+    local path=""
+    local -a words_seen
+    words_seen=(\${words[2,CURRENT-1]})
+
+    for word in $words_seen; do
+        case "$word" in
+            -*) continue ;;
+        esac
+        if [[ -z "$path" ]]; then path="$word"; else path="$path $word"; fi
+    done
+
+    case "$path" in
+${cases.join('\n')}
+        *) opts=() ;;
+    esac
+
+    if (( \${#opts} )); then
+        _describe 'command' opts
+    else
+        _files
+    fi
+}
+
+compdef _tsoft tsoft
+`;
+}
+
+function renderFish(tree) {
+    const lines = [
+        '# tsoft completion for fish',
+        '# Install: tsoft completion fish > ~/.config/fish/completions/tsoft.fish',
+        '',
+        'function __tsoft_path',
+        '    set -l tokens (commandline -opc)',
+        '    set -l parts',
+        '    for token in $tokens[2..-1]',
+        '        string match -q -- "-*" $token; and continue',
+        '        set -a parts $token',
+        '    end',
+        '    string join " " $parts',
+        'end',
+        '',
+    ];
+
+    for (const { path, description } of flatten(tree)) {
+        const parent = path.slice(0, -1).join(' ');
+        const name = path[path.length - 1];
+        const desc = description.replace(/'/g, "\\'");
+
+        lines.push(
+            `complete -c tsoft -f -n 'test (__tsoft_path) = "${parent}"' -a '${name}' -d '${desc}'`
+        );
+    }
+
+    return lines.join('\n') + '\n';
+}
+
+export function renderCompletion(shell, tree) {
+    switch (shell) {
+        case 'bash':
+            return renderBash(tree);
+        case 'zsh':
+            return renderZsh(tree);
+        case 'fish':
+            return renderFish(tree);
+        default:
+            throw new Error(`Unsupported shell: ${shell}`);
+    }
+}

package/src/ui/help-renderer.js

@@ -63,6 +63,15 @@ const COMMAND_GROUPS = [
             { display: 'whoami',     descKey: 'help.cmd.whoami' },
             { display: 'org switch', descKey: 'help.cmd.org_switch' },
         ]
+    },
+    {
+        groupKey: 'help.group.help',
+        commands: [
+            { display: 'docs',       descKey: 'help.cmd.docs' },
+            { display: 'completion', descKey: 'help.cmd.completion' },
+            { display: 'upgrade',    descKey: 'help.cmd.upgrade' },
+            { display: 'config autoupgrade', descKey: 'help.cmd.config' },
+        ]
     }
 ];
 

package/src/ui/table.js

@@ -0,0 +1,122 @@
+import chalk from 'chalk';
+import stringWidth from 'string-width';
+
+const GAP = 2;
+const ELLIPSIS = '…';
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+const RESET = '\u001b[39m';
+const MIN_COLUMN = 6;
+
+function truncateVisible(cell, limit) {
+    if (limit <= 0) {
+        return '';
+    }
+
+    if (stringWidth(cell) <= limit) {
+        return cell;
+    }
+
+    const target = limit - 1;
+    let out = '';
+    let width = 0;
+    let index = 0;
+
+    while (index < cell.length) {
+        ANSI_PATTERN.lastIndex = index;
+        const match = ANSI_PATTERN.exec(cell);
+
+        if (match && match.index === index) {
+            out += match[0];
+            index += match[0].length;
+            continue;
+        }
+
+        const char = cell[index];
+        const charWidth = stringWidth(char);
+
+        if (width + charWidth > target) {
+            break;
+        }
+
+        out += char;
+        width += charWidth;
+        index += 1;
+    }
+
+    const closer = hasOpenStyle(out) ? RESET : '';
+
+    return `${out}${ELLIPSIS}${closer}`;
+}
+
+function hasOpenStyle(text) {
+    const codes = text.match(ANSI_PATTERN) ?? [];
+
+    return codes.length > 0 && codes[codes.length - 1] !== RESET;
+}
+
+function columnWidths(rows, columnCount) {
+    const widths = new Array(columnCount).fill(0);
+
+    for (const row of rows) {
+        for (let i = 0; i < columnCount; i++) {
+            widths[i] = Math.max(widths[i], stringWidth(row[i] ?? ''));
+        }
+    }
+
+    return widths;
+}
+
+function fitToWidth(widths, available) {
+    const total = widths.reduce((sum, w) => sum + w, 0) + GAP * (widths.length - 1);
+
+    if (total <= available) {
+        return widths;
+    }
+
+    const fitted = [...widths];
+    let overflow = total - available;
+
+    while (overflow > 0) {
+        const widest = fitted.reduce(
+            (best, w, i) => (w > fitted[best] ? i : best),
+            0
+        );
+
+        if (fitted[widest] <= MIN_COLUMN) {
+            break;
+        }
+
+        fitted[widest] -= 1;
+        overflow -= 1;
+    }
+
+    return fitted;
+}
+
+export function renderTable({ head = null, rows, width = null, indent = '' }) {
+    if (!rows.length) {
+        return '';
+    }
+
+    const body = head ? [head.map((h) => chalk.dim(h)), ...rows] : rows;
+    const columnCount = Math.max(...body.map((row) => row.length));
+    const available = (width ?? process.stdout.columns ?? 80) - indent.length;
+    const widths = fitToWidth(columnWidths(body, columnCount), available);
+
+    return body
+        .map((row) => {
+            const cells = [];
+
+            for (let i = 0; i < columnCount; i++) {
+                const cell = truncateVisible(row[i] ?? '', widths[i]);
+                const padding = i === columnCount - 1
+                    ? ''
+                    : ' '.repeat(Math.max(0, widths[i] - stringWidth(cell) + GAP));
+
+                cells.push(cell + padding);
+            }
+
+            return (indent + cells.join('')).trimEnd();
+        })
+        .join('\n');
+}

package/src/ui/workspace-hint.js

@@ -0,0 +1,78 @@
+import path from 'path';
+import chalk from 'chalk';
+import { normalizeStoreDomain } from '../storage.js';
+import { t } from '../i18n.js';
+
+const THEME_CONTEXT_COMMANDS = new Set([
+    'theme dev',
+    'theme push',
+    'theme publish',
+    'theme submit',
+    'theme section list',
+    'theme section add',
+    'theme section create',
+    'theme section fork',
+]);
+
+export function commandUsesThemeContext(commandPath) {
+    return THEME_CONTEXT_COMMANDS.has(commandPath);
+}
+
+function cdTarget(store, theme, workspaceRoot) {
+    const relative = path.join(normalizeStoreDomain(store), theme);
+
+    return workspaceRoot ? path.join(workspaceRoot, relative) : relative;
+}
+
+function standingInTheme({ context, activeStore, activeTheme }) {
+    return Boolean(
+        context?.theme &&
+        context.store === activeStore &&
+        context.theme === activeTheme
+    );
+}
+
+export function buildWorkspaceHint({ context, activeStore, activeTheme, workspaceRoot = null }) {
+    if (!activeStore || !activeTheme) {
+        return null;
+    }
+
+    if (standingInTheme({ context, activeStore, activeTheme })) {
+        return null;
+    }
+
+    return {
+        store: activeStore,
+        theme: activeTheme,
+        cd: cdTarget(activeStore, activeTheme, workspaceRoot),
+    };
+}
+
+export function buildThemeMissingHint({ context, activeStore, activeTheme, workspaceRoot = null }) {
+    if (standingInTheme({ context, activeStore, activeTheme })) {
+        return { reason: 'not-downloaded', store: activeStore, theme: activeTheme, cd: null };
+    }
+
+    return {
+        reason: 'wrong-directory',
+        store: activeStore,
+        theme: activeTheme,
+        cd: activeStore && activeTheme ? cdTarget(activeStore, activeTheme, workspaceRoot) : null,
+    };
+}
+
+export function formatWorkspaceHint(hint) {
+    return [
+        chalk.yellow(t('context.outside_theme', { store: hint.store, theme: hint.theme })),
+        chalk.gray('   ' + t('context.cd_hint')),
+        chalk.white(`   cd ${hint.cd}`),
+    ].join('\n');
+}
+
+export function formatThemeMissingHint(hint, themePath) {
+    if (hint.reason === 'not-downloaded') {
+        return t('dev.theme_not_downloaded', { path: themePath });
+    }
+
+    return t('dev.theme_wrong_directory', { path: themePath, cd: hint.cd });
+}

package/src/upgrade-plan.js

@@ -0,0 +1,43 @@
+import semver from 'semver';
+
+export const PACKAGE_NAME = 'tsoft-cli';
+
+export function detectInstallMethod({ modulePath, env = process.env }) {
+    const normalized = modulePath.replace(/\\/g, '/');
+
+    if (normalized.includes('/_npx/') || env.npm_command === 'exec') {
+        return 'npx';
+    }
+
+    if (normalized.includes('/.volta/') || env.VOLTA_HOME) {
+        return 'volta';
+    }
+
+    if (normalized.includes('/lib/node_modules/')) {
+        return 'npm-global';
+    }
+
+    return 'unknown';
+}
+
+export function upgradeCommandFor(method) {
+    switch (method) {
+        case 'npm-global':
+            return `npm install -g ${PACKAGE_NAME}@latest`;
+        case 'volta':
+            return `volta install ${PACKAGE_NAME}@latest`;
+        default:
+            return null;
+    }
+}
+
+export function isNewerAvailable(installed, published) {
+    const current = semver.valid(installed);
+    const latest = semver.valid(published);
+
+    if (!current || !latest) {
+        return false;
+    }
+
+    return semver.gt(latest, current);
+}