@contextual-io/cli 0.6.0 → 0.7.1

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @contextual-io/cli
 $ ctxl COMMAND
 running command...
 $ ctxl (--version)
-@contextual-io/cli/0.6.0 linux-x64 node-v25.2.1
+@contextual-io/cli/0.7.1 linux-x64 node-v25.9.0
 $ ctxl --help [COMMAND]
 USAGE
   $ ctxl COMMAND

package/dist/hooks/init/index.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from "@oclif/core";
+declare const hook: Hook.Init;
+export default hook;

package/dist/hooks/init/index.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+import { boxMessage } from "../../utils/message.js";
+import { checkForUpdate, hasNotifiedVersion, markChecked } from "../../utils/update-check.js";
+const defaultCheckFrequencyMs = 6 * 60 * 60 * 1000;
+const dayMs = 24 * 60 * 60 * 1000;
+const getUpdateMessage = ({ binName, currentVersion, latestVersion, packageName }) => boxMessage([
+    `A newer version of ${chalk.blueBright(chalk.bold(binName))} is available: ${chalk.bold(currentVersion)} -> ${chalk.bold(latestVersion)}`,
+    `Install ${chalk.greenBright(chalk.bold(packageName + "@latest"))} with your preferred package manager.`,
+].join("\n")) + "\n\n";
+const hook = async function ({ config }) {
+    if (config.scopedEnvVarTrue("DISABLE_UPDATE_CHECK"))
+        return;
+    const updateCheckDays = Number.parseInt(config.scopedEnvVar("UPDATE_CHECK_DAYS") ?? "0", 10);
+    if (!Number.isSafeInteger(updateCheckDays) || updateCheckDays < 0)
+        return;
+    const checkFrequencyMs = updateCheckDays > 0 ? updateCheckDays * dayMs : defaultCheckFrequencyMs;
+    const result = await checkForUpdate({
+        currentVersion: config.version,
+        packageName: config.pjson.name,
+        timeoutMs: checkFrequencyMs,
+    });
+    if (!result) {
+        markChecked({ cacheDir: config.cacheDir });
+        return;
+    }
+    if (result.updateAvailable && !hasNotifiedVersion({ cacheDir: config.cacheDir, latestVersion: result.latestVersion })) {
+        process.stderr.write(getUpdateMessage({
+            binName: config.bin,
+            currentVersion: result.currentVersion,
+            latestVersion: result.latestVersion,
+            packageName: config.pjson.name,
+        }));
+        markChecked({ cacheDir: config.cacheDir, notifiedVersion: result.latestVersion });
+        return;
+    }
+    markChecked({ cacheDir: config.cacheDir });
+};
+export default hook;

package/dist/utils/message.d.ts

@@ -0,0 +1,14 @@
+type BoxOptions = {
+    borderColorFn?: (text: string) => string;
+    bottomLeftBorderChar?: string;
+    bottomRightBorderChar?: string;
+    textColorFn?: (text: string) => string;
+    topLeftBorderChar?: string;
+    topRightBorderChar?: string;
+    xBorderChar?: string;
+    xPadding?: number;
+    yBorderChar?: string;
+    yPadding?: number;
+};
+export declare const boxMessage: (message: string, { borderColorFn, textColorFn, xPadding, yPadding, }?: BoxOptions) => string;
+export {};

package/dist/utils/message.js

@@ -0,0 +1,31 @@
+import chalk from "chalk";
+import { stripVTControlCharacters } from "node:util";
+const BoxTL = "╭";
+const BoxTR = "╮";
+const BoxBL = "╰";
+const BoxBR = "╯";
+const BoxX = "─";
+const BoxY = "│";
+const getVisibleLength = (value) => stripVTControlCharacters(value).length;
+export const boxMessage = (message, { borderColorFn = (text) => chalk.yellow(text), textColorFn = (text) => chalk.white(text), xPadding = 2, yPadding = 0, } = {}) => {
+    xPadding = Math.max(0, xPadding);
+    yPadding = Math.max(0, yPadding);
+    const lines = message.split("\n");
+    const maxLength = Math.max(...lines.map(line => getVisibleLength(line)));
+    const totalInnerWidth = maxLength + xPadding * 2;
+    const leftPadding = " ".repeat(xPadding);
+    const topBorder = borderColorFn(`${BoxTL}${BoxX.repeat(totalInnerWidth)}${BoxTR}`);
+    const bottomBorder = borderColorFn(`${BoxBL}${BoxX.repeat(totalInnerWidth)}${BoxBR}`);
+    const yPaddingLines = Array.from({ length: yPadding }, () => `${textColorFn(BoxY)}${" ".repeat(totalInnerWidth)}${textColorFn(BoxY)}`);
+    const contentLines = lines.map(line => {
+        const rightPadding = " ".repeat(maxLength - getVisibleLength(line) + xPadding);
+        return `${borderColorFn(BoxY)}${leftPadding}${textColorFn(line)}${rightPadding}${borderColorFn(BoxY)}`;
+    });
+    return [
+        topBorder,
+        ...yPaddingLines,
+        ...contentLines,
+        ...yPaddingLines,
+        bottomBorder,
+    ].join("\n");
+};

package/dist/utils/update-check.d.ts

@@ -0,0 +1,23 @@
+export type UpdateCheckResult = {
+    currentVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+};
+export declare const compareVersions: (left: string, right: string) => -1 | 0 | 1;
+export declare const checkForUpdate: ({ currentVersion, packageName, timeoutMs, }: {
+    currentVersion: string;
+    packageName: string;
+    timeoutMs?: number;
+}) => Promise<undefined | UpdateCheckResult>;
+export declare const shouldRunPeriodicCheck: ({ cacheDir, frequencyMs, }: {
+    cacheDir: string;
+    frequencyMs: number;
+}) => boolean;
+export declare const markChecked: ({ cacheDir, notifiedVersion, }: {
+    cacheDir: string;
+    notifiedVersion?: string;
+}) => void;
+export declare const hasNotifiedVersion: ({ cacheDir, latestVersion, }: {
+    cacheDir: string;
+    latestVersion: string;
+}) => boolean;

package/dist/utils/update-check.js

@@ -0,0 +1,101 @@
+import fetch from "cross-fetch";
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+const NpmLatestVersionResponse = z.object({
+    version: z.string(),
+});
+const updateCheckFileName = "update-check.json";
+const parseVersionPart = (value) => {
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? 0 : parsed;
+};
+const splitVersion = (version) => {
+    const trimmed = version.startsWith("v") ? version.slice(1) : version;
+    const [corePart, prerelease] = trimmed.split("-", 2);
+    const core = corePart.split(".").map((part) => parseVersionPart(part));
+    return { core, prerelease };
+};
+export const compareVersions = (left, right) => {
+    const leftVersion = splitVersion(left);
+    const rightVersion = splitVersion(right);
+    const maxLength = Math.max(leftVersion.core.length, rightVersion.core.length);
+    for (let i = 0; i < maxLength; i += 1) {
+        const leftPart = leftVersion.core[i] ?? 0;
+        const rightPart = rightVersion.core[i] ?? 0;
+        if (leftPart > rightPart)
+            return 1;
+        if (leftPart < rightPart)
+            return -1;
+    }
+    if (!leftVersion.prerelease && rightVersion.prerelease)
+        return 1;
+    if (leftVersion.prerelease && !rightVersion.prerelease)
+        return -1;
+    return 0;
+};
+const readState = (cacheDir) => {
+    const statePath = path.join(cacheDir, updateCheckFileName);
+    if (!fs.existsSync(statePath))
+        return {};
+    try {
+        const rawState = fs.readFileSync(statePath, "utf8");
+        return JSON.parse(rawState);
+    }
+    catch {
+        return {};
+    }
+};
+const writeState = (cacheDir, state) => {
+    if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    const statePath = path.join(cacheDir, updateCheckFileName);
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), "utf8");
+};
+const fetchLatestVersion = async (packageName, timeoutMs) => {
+    try {
+        const encodedPackageName = encodeURIComponent(packageName);
+        const response = await fetch(`https://registry.npmjs.org/${encodedPackageName}/latest`, {
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok)
+            return undefined;
+        const { version } = NpmLatestVersionResponse.parse(await response.json());
+        return version;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const checkForUpdate = async ({ currentVersion, packageName, timeoutMs = 1500, }) => {
+    const latestVersion = await fetchLatestVersion(packageName, timeoutMs);
+    if (!latestVersion)
+        return undefined;
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable: compareVersions(latestVersion, currentVersion) > 0,
+    };
+};
+export const shouldRunPeriodicCheck = ({ cacheDir, frequencyMs, }) => {
+    const state = readState(cacheDir);
+    if (!state.lastCheckedAt)
+        return true;
+    const lastCheckedAt = new Date(state.lastCheckedAt).getTime();
+    if (Number.isNaN(lastCheckedAt))
+        return true;
+    return Date.now() - lastCheckedAt >= frequencyMs;
+};
+export const markChecked = ({ cacheDir, notifiedVersion, }) => {
+    const state = readState(cacheDir);
+    writeState(cacheDir, {
+        ...state,
+        lastCheckedAt: new Date().toISOString(),
+        lastNotifiedVersion: notifiedVersion ?? state.lastNotifiedVersion,
+    });
+};
+export const hasNotifiedVersion = ({ cacheDir, latestVersion, }) => {
+    const state = readState(cacheDir);
+    return state.lastNotifiedVersion === latestVersion;
+};

package/oclif.manifest.json

@@ -1259,5 +1259,5 @@
       ]
     }
   },
-  "version": "0.6.0"
+  "version": "0.7.1"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextual-io/cli",
   "description": "Contextual CLI",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "author": "Nasser Oloumi",
   "bin": {
     "ctxl": "./bin/run.js"
@@ -11,7 +11,7 @@
     "@oclif/plugin-autocomplete": "^3.2.39",
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-not-found": "^3.2.73",
-    "@oclif/table": "^0.5.1",
+    "@oclif/table": "^0.5.2",
     "chalk": "^5.6.2",
     "cross-fetch": "^4.1.0",
     "open": "^11.0.0",
@@ -33,7 +33,7 @@
     "eslint-config-prettier": "^10",
     "eslint-plugin-unused-imports": "^4.3.0",
     "mocha": "^10",
-    "oclif": "^4",
+    "oclif": "^4.22.81",
     "shx": "^0.3.3",
     "ts-node": "^10",
     "typescript": "^5"
@@ -57,6 +57,9 @@
     "bin": "ctxl",
     "dirname": "ctxl",
     "commands": "./dist/commands",
+    "hooks": {
+      "init": "./dist/hooks/init/index.js"
+    },
     "plugins": [
       "@oclif/plugin-help",
       "@oclif/plugin-not-found",