@tuanhv/op-cli 0.1.1 → 0.2.0

package/dist/output/table.js

@@ -1,14 +1,119 @@
 import { isFlatLink } from "../core/hal.js";
-export function renderTable(header, rows) {
-    const widths = header.map((title, column) => Math.max(title.length, ...rows.map((row) => row[column]?.length ?? 0)));
+/** Gap between two columns, in display cells. */
+const COLUMN_GAP = 2;
+/**
+ * Display width of one string: East Asian wide characters count two
+ * cells, combining marks count none, everything else one. An
+ * approximation by design: it fixes Vietnamese NFD and CJK tables
+ * without weighing the CLI down with a full Unicode width table.
+ */
+export function displayWidth(text) {
+    let width = 0;
+    for (const character of text) {
+        const code = character.codePointAt(0) ?? 0;
+        if (isZeroWidth(code)) {
+            continue;
+        }
+        width += isWide(code) ? 2 : 1;
+    }
+    return width;
+}
+function isZeroWidth(code) {
+    return ((code >= 0x0300 && code <= 0x036f)
+        || (code >= 0x200b && code <= 0x200f)
+        || (code >= 0xfe00 && code <= 0xfe0f)
+        || code === 0xfeff);
+}
+function isWide(code) {
+    return ((code >= 0x1100 && code <= 0x115f)
+        || (code >= 0x2e80 && code <= 0x303e)
+        || (code >= 0x3041 && code <= 0x33ff)
+        || (code >= 0x3400 && code <= 0x4dbf)
+        || (code >= 0x4e00 && code <= 0x9fff)
+        || (code >= 0xa000 && code <= 0xa4cf)
+        || (code >= 0xa960 && code <= 0xa97f)
+        || (code >= 0xac00 && code <= 0xd7a3)
+        || (code >= 0xf900 && code <= 0xfaff)
+        || (code >= 0xfe10 && code <= 0xfe19)
+        || (code >= 0xfe30 && code <= 0xfe6f)
+        || (code >= 0xff00 && code <= 0xff60)
+        || (code >= 0xffe0 && code <= 0xffe6)
+        || (code >= 0x1f300 && code <= 0x1f64f)
+        || (code >= 0x1f900 && code <= 0x1f9ff));
+}
+/** The longest prefix of `text` that fits `target` cells, "…" if cut. */
+function truncateToWidth(text, target) {
+    if (displayWidth(text) <= target) {
+        return text;
+    }
+    let kept = "";
+    let width = 0;
+    for (const character of text) {
+        const cell = displayWidth(character);
+        if (width + cell > target - 1) {
+            break;
+        }
+        kept += character;
+        width += cell;
+    }
+    return kept + "…";
+}
+function padToWidth(text, target) {
+    return text + " ".repeat(Math.max(0, target - displayWidth(text)));
+}
+/**
+ * Terminal width for table bounding, when stdout is a TTY. Piped and
+ * captured output (tests, scripts) reports undefined and stays unbounded.
+ */
+export function terminalWidth() {
+    const columns = process.stdout?.columns;
+    return typeof columns === "number" && columns > 0 ? columns : undefined;
+}
+/**
+ * Column budgets that fit `maxWidth`: the widest column yields a cell
+ * at a time, so one long subject narrows instead of every column
+ * starving. Headers are truncated like data; a budget never drops
+ * below one cell.
+ */
+function shrinkColumns(widths, maxWidth) {
+    const budgets = [...widths];
+    const total = () => budgets.reduce((sum, width) => sum + width, 0);
+    while (total() > maxWidth) {
+        let widest = 0;
+        for (let column = 1; column < budgets.length; column += 1) {
+            if (budgets[column] > budgets[widest]) {
+                widest = column;
+            }
+        }
+        if (budgets[widest] <= 1) {
+            break;
+        }
+        budgets[widest] = budgets[widest] - 1;
+    }
+    return budgets;
+}
+export function renderTable(header, rows, maxWidth) {
+    const limit = maxWidth ?? terminalWidth();
+    const naturalWidths = header.map((title, column) => Math.max(displayWidth(title), ...rows.map((row) => displayWidth(row[column] ?? ""))));
+    const unbounded = limit === undefined
+        || naturalWidths.reduce((sum, width) => sum + width, 0)
+            + COLUMN_GAP * Math.max(0, header.length - 1)
+            <= limit;
+    const widths = unbounded
+        ? naturalWidths
+        : shrinkColumns(naturalWidths, limit - COLUMN_GAP * Math.max(0, header.length - 1));
     const line = (cells) => cells
         .map((cell, column) => {
         const width = widths[column];
-        return column === cells.length - 1 || width === undefined
-            ? cell
-            : cell.padEnd(width);
+        if (width === undefined) {
+            return cell;
+        }
+        const bounded = unbounded ? cell : truncateToWidth(cell, width);
+        return column === cells.length - 1
+            ? bounded
+            : padToWidth(bounded, width);
     })
-        .join("  ")
+        .join(" ".repeat(COLUMN_GAP))
         .trimEnd();
     return [line(header), ...rows.map(line)].join("\n") + "\n";
 }

package/dist/run.js

@@ -1,4 +1,5 @@
-import { listProfiles, removeProfile, requireStoredName, resolveProfile, parseOptionalId, saveProfile, setActiveProfile, LOGIN_PROFILE, } from "./context/profile.js";
+import { listProfiles, removeProfile, requireStoredName, resolveProfile, parseProjectOverride, saveProfile, setActiveProfile, LOGIN_PROFILE, } from "./context/profile.js";
+import { resolveProjectOverride } from "./context/projectref.js";
 import { OpCliError, renderJsonError, renderTextError } from "./core/errors.js";
 import { usageErrorFrom } from "./core/usage.js";
 import { authenticate, bindRequestTimeout } from "./core/http.js";
@@ -9,6 +10,7 @@ import { registerWpCommands } from "./commands/wp.js";
 import { registerProjectCommands } from "./commands/project.js";
 import { registerTimeCommands } from "./commands/time.js";
 import { buildVersionOutput } from "./commands/version.js";
+import { registerUpdateCommand, startVersionNotice } from "./commands/update.js";
 import { Command, CommanderError } from "commander";
 export async function run(argv, env, io) {
     let stdout = "";
@@ -16,6 +18,9 @@ export async function run(argv, env, io) {
     // Spec story 51: one environment variable makes JSON the output for
     // the whole session, errors included, instead of a flag per command.
     let jsonOutput = env.OP_CLI_OUTPUT === "json";
+    // The update command forwards the installer's own exit code; every
+    // other success path stays 0.
+    let forcedExitCode;
     // Keyed by the thrown error because Commander hands the failing command
     // to its own exit callback and to nobody else.
     const failedIn = new WeakMap();
@@ -49,11 +54,13 @@ export async function run(argv, env, io) {
         .command("login")
         .description("Verify and store OpenProject credentials")
         .option("--profile <name>", 'profile to create or update, defaults to "default"')
-        .option("--project <id>", "default project stored on the profile")
+        .option("--project <name-or-id>", "default project stored on the profile")
         .action(async (options) => {
         if (!io.prompt || io.stdinIsTTY !== true) {
             throw new OpCliError("USAGE_ERROR", "auth login requires an interactive terminal.", "set OPENPROJECT_URL and OPENPROJECT_API_KEY in the environment for non-interactive use.");
         }
+        // Flag misuse is refused before the interactive prompt starts.
+        const projectRef = parseProjectOverride(options.project);
         const enteredUrl = await io.prompt("Instance URL: ", false);
         const apiKey = await io.prompt("API key: ", true);
         let parsedUrl;
@@ -68,8 +75,11 @@ export async function run(argv, env, io) {
         }
         const instanceUrl = parsedUrl.toString().replace(/\/+$/, "");
         const profileName = options.profile ?? LOGIN_PROFILE;
-        const project = parseOptionalId(options.project);
         const user = await authenticate(instanceUrl, apiKey);
+        let project = projectRef;
+        if (typeof project === "string") {
+            project = await resolveProjectOverride(instanceUrl, apiKey, project);
+        }
         await saveProfile(env, instanceUrl, apiKey, profileName, project);
         stdout +=
             `Authenticated ${user.name} at ${instanceUrl} ` +
@@ -80,12 +90,12 @@ export async function run(argv, env, io) {
         .description("Show the active profile and authenticated user")
         .option("--json", "emit a JSON object")
         .option("--profile <name>", "use this profile for this command only")
-        .option("--project <id>", "override the profile default project")
+        .option("--project <name-or-id>", "override the profile default project")
         .action(async (options) => {
         jsonOutput = options.json === true;
         const profile = await resolveProfile(env, {
             profile: options.profile,
-            project: parseOptionalId(options.project),
+            project: parseProjectOverride(options.project),
         });
         const user = await authenticate(profile.instanceUrl, profile.apiKey);
         if (options.json) {
@@ -133,11 +143,17 @@ export async function run(argv, env, io) {
         .command("use")
         .description("Set the active profile")
         .argument("<profile>")
-        .option("--project <id>", "change the profile's default project")
+        .option("--project <name-or-id>", "change the profile's default project")
         .action(async (profile, options) => {
-        await setActiveProfile(env, profile, {
-            project: parseOptionalId(options.project),
-        });
+        // A named project resolves against the target profile's own
+        // instance so what gets stored is a numeric id, like every other
+        // surface; ids and an absent flag never touch the network.
+        let project = parseProjectOverride(options.project);
+        if (typeof project === "string") {
+            const target = await resolveProfile(env, { profile });
+            project = await resolveProjectOverride(target.instanceUrl, target.apiKey, project);
+        }
+        await setActiveProfile(env, profile, { project });
         stdout += `Switched to profile ${profile}.\n`;
     });
     auth
@@ -222,11 +238,31 @@ export async function run(argv, env, io) {
             jsonOutput = on;
         },
     });
+    const update = program
+        .command("update")
+        .description("Update the CLI to the latest published release");
+    registerUpdateCommand(update, {
+        env,
+        write: (text) => {
+            stdout += text;
+        },
+        writeErr: (text) => {
+            stderr += text;
+        },
+        setExitCode: (code) => {
+            forcedExitCode = code;
+        },
+        ...(io.runExternal === undefined ? {} : { runExternal: io.runExternal }),
+        ...(io.captureExternal === undefined ? {} : { captureExternal: io.captureExternal }),
+    });
     // Registered lazily and only at the root so a subcommand can reuse
-    // the "--version <value>" spelling as its own option (wp list).
+    // the "--version <value>" spelling as its own option (wp list); a
+    // root-level version flag hijacks that filter. Root help still
+    // advertises the invocation.
     if (argv[0] === "--version") {
         program.version(await buildVersionOutput(env), "--version", "print version information");
     }
+    program.addHelpText("after", "\nRun op-cli --version for version information.");
     // Commands built declaratively start as standalone Command objects, so
     // they miss the root's exitOverride and output capture; without this
     // walk their --help would print to the real stdout and process.exit,
@@ -259,8 +295,17 @@ export async function run(argv, env, io) {
         // Environment misuse is refused before any command runs: a request
         // budget that silently fell back would hide the user's mistake.
         bindRequestTimeout(env);
+        // Started before the parse so the registry lookup overlaps the
+        // command itself; a slow registry then costs nothing extra.
+        const versionNotice = startVersionNotice(argv, env, io);
         await program.parseAsync([...argv], { from: "user" });
-        return { stdout, stderr, exitCode: 0 };
+        const noticeLine = await versionNotice;
+        // The notice never mixes with a stderr that already spoke (a
+        // truncation warning, a JSON error object): it stays quiet then.
+        if (noticeLine !== undefined && stderr === "") {
+            stderr += noticeLine;
+        }
+        return { stdout, stderr, exitCode: forcedExitCode ?? 0 };
     }
     catch (error) {
         if (error instanceof CommanderError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tuanhv/op-cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "A resolving command-line client for OpenProject",
   "license": "MIT",
   "author": "hoangvantuan",
@@ -30,6 +30,7 @@
   "files": [
     "dist",
     "!dist/**/*.map",
+    "LICENSE",
     "NOTICE"
   ],
   "scripts": {