@greenarmor/ges 1.5.4 → 1.5.5

package/dist/cli.js

@@ -19,12 +19,29 @@ import { hooksCommand } from "./commands/hooks.js";
 import { dashboardCommand } from "./commands/dashboard.js";
 import { governanceCommand } from "./commands/governance.js";
 import { assignCommand } from "./commands/assign.js";
-import { CLI_VERSION } from "./utils/version.js";
+import { CLI_VERSION, AUTHOR, RELEASE_DATE, DONATE_URL, HOMEPAGE } from "./utils/version.js";
+import { showUpdateNoticeIfNeeded } from "./utils/update-notice.js";
+import { BOLD, DIM, CYAN, GRAY, MAGENTA } from "./utils/ui.js";
+const versionDisplay = [
+    ``,
+    `  ${BOLD(MAGENTA("GESF"))} ${BOLD(`v${CLI_VERSION}`)}`,
+    `  ${GRAY("Green Engineering Standard Framework")}`,
+    ``,
+    `  ${DIM("Author:")}    ${AUTHOR}`,
+    `  ${DIM("Released:")}  ${RELEASE_DATE}`,
+    ``,
+    `  ${DIM("Support:")}   ${CYAN(DONATE_URL)}`,
+    `  ${DIM("GitHub:")}    ${GRAY(HOMEPAGE)}`,
+    ``,
+].join("\n");
 const program = new Command();
 program
     .name("ges")
     .description("Green Engineering Standard Framework - Compliance-as-Code CLI")
-    .version(CLI_VERSION);
+    .version(versionDisplay, "-v, --version", "Output the version number");
+program.hook("preAction", async (_thisCommand, actionCommand) => {
+    await showUpdateNoticeIfNeeded(actionCommand.name());
+});
 program.addCommand(initCommand);
 program.addCommand(auditCommand);
 program.addCommand(scoreCommand);

package/dist/commands/update.js

@@ -1,10 +1,90 @@
 import { Command } from "commander";
 import { CLI_VERSION } from "../utils/version.js";
 import { showNextStepsMenu } from "../utils/next-steps.js";
+import { checkForUpdate, compareVersions, dismissVersion, disableUpdateChecks, enableUpdateChecks, isInteractive, NPM_PACKAGE, } from "../utils/update-check.js";
+import { banner, blank, divider, success, error, warn, info, kv, label, GREEN, YELLOW, DIM, CYAN, } from "../utils/ui.js";
+import { confirm } from "../utils/prompts.js";
 export const updateCommand = new Command("update")
     .description("Check for GESF updates")
-    .action(async () => {
-    console.log(`\n  GESF Version: ${CLI_VERSION}`);
-    console.log("  Update check: Run 'npm update -g @greenarmor/ges' or 'pnpm update -g @greenarmor/ges'\n");
+    .option("--check", "Only check for updates, don't install")
+    .option("--disable-checks", "Disable automatic update notifications")
+    .option("--enable-checks", "Re-enable automatic update notifications")
+    .action(async (options) => {
+    if (options.disableChecks) {
+        disableUpdateChecks();
+        success("Update checks disabled.", "You won't see update notifications anymore.");
+        info("Re-enable", "ges update --enable-checks");
+        blank();
+        return;
+    }
+    if (options.enableChecks) {
+        enableUpdateChecks();
+        success("Update checks enabled.", "You'll see update notifications when new versions are available.");
+        blank();
+        return;
+    }
+    banner("GESF Update", "Version check & upgrade");
+    info("Current version", CLI_VERSION);
+    kv("Package", NPM_PACKAGE);
+    blank();
+    label("Checking npm registry for latest version...");
+    const result = await checkForUpdate(true);
+    if (!result.latestVersion) {
+        warn("Could not reach npm registry.", "Check your network connection and try again.");
+        console.log(`  ${DIM("Or check manually:")} ${CYAN("npm view @greenarmor/ges version")}\n`);
+        await showNextStepsMenu("update");
+        return;
+    }
+    kv("Latest version", result.latestVersion);
+    blank();
+    if (compareVersions(result.latestVersion, CLI_VERSION) <= 0) {
+        success("You're up to date!", `Running ${CLI_VERSION} (latest).`);
+        blank();
+        await showNextStepsMenu("update");
+        return;
+    }
+    divider();
+    console.log(`  ${YELLOW("↻")} ${YELLOW(`Update available: ${CLI_VERSION} → ${result.latestVersion}`)}`);
+    divider();
+    blank();
+    if (options.check || !isInteractive()) {
+        console.log(`  ${DIM("To update:")}`);
+        console.log(`    ${GREEN("npm install -g @greenarmor/ges@latest")}`);
+        console.log(`    ${DIM("or")}`);
+        console.log(`    ${GREEN("pnpm add -g @greenarmor/ges@latest")}\n`);
+        await showNextStepsMenu("update");
+        return;
+    }
+    const shouldUpdate = await confirm({
+        message: `Install @greenarmor/ges@${result.latestVersion} now?`,
+        default: true,
+    });
+    if (!shouldUpdate) {
+        const dismiss = await confirm({
+            message: `Skip this version (${result.latestVersion})?`,
+            default: false,
+        });
+        if (dismiss) {
+            dismissVersion(result.latestVersion);
+            success("Version skipped.", `You won't be reminded about ${result.latestVersion} again.`);
+        }
+        blank();
+        await showNextStepsMenu("update");
+        return;
+    }
+    blank();
+    info("Installing", `${CYAN(`${NPM_PACKAGE}@latest`)}`);
+    divider();
+    const { execSync } = await import("node:child_process");
+    try {
+        execSync(`npm install -g ${NPM_PACKAGE}@latest`, { stdio: "inherit" });
+        blank();
+        success("Update complete!", `Installed ${result.latestVersion}.`);
+        blank();
+    }
+    catch {
+        error("Update failed.", "Try manually: npm install -g @greenarmor/ges@latest");
+        blank();
+    }
     await showNextStepsMenu("update");
 });

package/dist/utils/ui.d.ts

@@ -34,4 +34,6 @@ export declare function progressBar(current: number, total: number, width?: numb
 export declare function statusBadge(status: string): string;
 export declare function severityBadge(severity: string): string;
 export declare function gradeColor(grade: string): string;
+export declare function updateNoticeBox(current: string, latest: string): void;
+export declare function updateNoticeLine(current: string, latest: string): void;
 export { chalk, icons, DIM, BOLD, GREEN, RED, YELLOW, CYAN, MAGENTA, GRAY };

package/dist/utils/ui.js

@@ -112,4 +112,25 @@ export function gradeColor(grade) {
         return MAGENTA(BOLD(grade));
     return RED(BOLD(grade));
 }
+export function updateNoticeBox(current, latest) {
+    const inner = `  ${YELLOW(BOLD("↻"))}  ${BOLD("Update available")}  ${DIM(GRAY(current))} ${GRAY("→")} ${GREEN(latest)}`;
+    const innerLine2 = `     ${DIM("Run")} ${CYAN("ges update")} ${DIM("to upgrade, or")} ${CYAN("npm i -g @greenarmor/ges@latest")}`;
+    const width = Math.max(inner.replace(/\x1b\[[0-9;]*m/g, "").length, 56) + 4;
+    const top = GRAY(`  ┌${"─".repeat(width)}┐`);
+    const mid1 = GRAY("  │") + " ".repeat(Math.max(0, (width - stripAnsi(inner).length) / 2 | 0)) + inner + " ".repeat(Math.max(0, width - stripAnsi(inner).length - ((width - stripAnsi(inner).length) / 2 | 0))) + GRAY("│");
+    const mid2 = GRAY("  │") + " ".repeat(Math.max(0, (width - stripAnsi(innerLine2).length) / 2 | 0)) + innerLine2 + " ".repeat(Math.max(0, width - stripAnsi(innerLine2).length - ((width - stripAnsi(innerLine2).length) / 2 | 0))) + GRAY("│");
+    const bot = GRAY(`  └${"─".repeat(width)}┘`);
+    console.log();
+    console.log(top);
+    console.log(mid1);
+    console.log(mid2);
+    console.log(bot);
+    console.log();
+}
+function stripAnsi(str) {
+    return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+export function updateNoticeLine(current, latest) {
+    console.error(`  ${YELLOW("↻")} ${DIM("Update available:")} ${current} ${GRAY("→")} ${latest}  ${DIM("Run")} ${CYAN("ges update")}`);
+}
 export { chalk, icons, DIM, BOLD, GREEN, RED, YELLOW, CYAN, MAGENTA, GRAY };

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

@@ -0,0 +1,14 @@
+declare const NPM_PACKAGE = "@greenarmor/ges";
+export declare function compareVersions(a: string, b: string): number;
+export declare function isInteractive(): boolean;
+export interface UpdateCheckResult {
+    currentVersion: string;
+    latestVersion: string | null;
+    updateAvailable: boolean;
+    dismissed: boolean;
+}
+export declare function checkForUpdate(force?: boolean): Promise<UpdateCheckResult>;
+export declare function dismissVersion(version: string): void;
+export declare function disableUpdateChecks(): void;
+export declare function enableUpdateChecks(): void;
+export { NPM_PACKAGE };

package/dist/utils/update-check.js

@@ -0,0 +1,117 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { execSync } from "node:child_process";
+import { CLI_VERSION } from "./version.js";
+const CACHE_DIR = path.join(os.homedir(), ".ges");
+const CACHE_FILE = path.join(CACHE_DIR, "update-check.json");
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const TIMEOUT_MS = 3000;
+const NPM_PACKAGE = "@greenarmor/ges";
+function defaultCache() {
+    return {
+        latest_version: null,
+        checked_at: null,
+        dismissed_versions: [],
+        disabled: false,
+    };
+}
+function readCache() {
+    try {
+        if (!fs.existsSync(CACHE_FILE))
+            return defaultCache();
+        const data = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+        return { ...defaultCache(), ...data };
+    }
+    catch {
+        return defaultCache();
+    }
+}
+function writeCache(cache) {
+    try {
+        if (!fs.existsSync(CACHE_DIR))
+            fs.mkdirSync(CACHE_DIR, { recursive: true });
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2) + "\n");
+    }
+    catch {
+        // best-effort cache — silent on failure
+    }
+}
+export function compareVersions(a, b) {
+    const pa = a.replace(/^[v]/, "").split(".").map((n) => parseInt(n, 10) || 0);
+    const pb = b.replace(/^[v]/, "").split(".").map((n) => parseInt(n, 10) || 0);
+    const len = Math.max(pa.length, pb.length);
+    for (let i = 0; i < len; i++) {
+        const va = pa[i] || 0;
+        const vb = pb[i] || 0;
+        if (va > vb)
+            return 1;
+        if (va < vb)
+            return -1;
+    }
+    return 0;
+}
+export function isInteractive() {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+function fetchLatestVersion() {
+    try {
+        const output = execSync(`npm view ${NPM_PACKAGE} version`, {
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: TIMEOUT_MS,
+            encoding: "utf-8",
+        });
+        const version = output.trim().split("\n").pop()?.trim() || "";
+        return version.match(/^\d+\.\d+\.\d+/) ? version : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkForUpdate(force = false) {
+    const cache = readCache();
+    if (cache.disabled) {
+        return { currentVersion: CLI_VERSION, latestVersion: null, updateAvailable: false, dismissed: false };
+    }
+    const now = Date.now();
+    const checkedAt = cache.checked_at ? new Date(cache.checked_at).getTime() : 0;
+    const isStale = now - checkedAt > CHECK_INTERVAL_MS;
+    let latest = cache.latest_version;
+    if (isStale || force) {
+        const shouldFetch = force || isInteractive();
+        if (shouldFetch) {
+            latest = fetchLatestVersion();
+            writeCache({
+                ...cache,
+                latest_version: latest ?? cache.latest_version,
+                checked_at: new Date().toISOString(),
+            });
+        }
+    }
+    const updateAvailable = latest ? compareVersions(latest, CLI_VERSION) > 0 : false;
+    const dismissed = latest ? cache.dismissed_versions.includes(latest) : false;
+    return {
+        currentVersion: CLI_VERSION,
+        latestVersion: latest,
+        updateAvailable,
+        dismissed,
+    };
+}
+export function dismissVersion(version) {
+    const cache = readCache();
+    if (!cache.dismissed_versions.includes(version)) {
+        cache.dismissed_versions.push(version);
+        writeCache(cache);
+    }
+}
+export function disableUpdateChecks() {
+    const cache = readCache();
+    cache.disabled = true;
+    writeCache(cache);
+}
+export function enableUpdateChecks() {
+    const cache = readCache();
+    cache.disabled = false;
+    writeCache(cache);
+}
+export { NPM_PACKAGE };

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

@@ -0,0 +1 @@
+export declare function showUpdateNoticeIfNeeded(currentCommandName?: string): Promise<void>;

package/dist/utils/update-notice.js

@@ -0,0 +1,50 @@
+import { checkForUpdate, dismissVersion, isInteractive, NPM_PACKAGE } from "./update-check.js";
+import { select } from "./prompts.js";
+import { updateNoticeBox, updateNoticeLine, blank, divider, info, success, error, GREEN, DIM, CYAN, YELLOW, } from "./ui.js";
+const SKIP_COMMANDS = new Set(["update", "mcp", "start"]);
+export async function showUpdateNoticeIfNeeded(currentCommandName) {
+    if (currentCommandName && SKIP_COMMANDS.has(currentCommandName))
+        return;
+    const result = await checkForUpdate();
+    if (!result.updateAvailable || result.dismissed || !result.latestVersion)
+        return;
+    if (!isInteractive()) {
+        updateNoticeLine(result.currentVersion, result.latestVersion);
+        return;
+    }
+    updateNoticeBox(result.currentVersion, result.latestVersion);
+    const action = await select({
+        message: "An update is available. What would you like to do?",
+        choices: [
+            { name: `${GREEN("Update now")} ${DIM("— install latest and exit")}`, value: "update" },
+            { name: `Skip for now ${DIM("— continue with current version")}`, value: "skip" },
+            { name: `${YELLOW("Skip this version")} ${DIM(`— don't remind me about ${result.latestVersion} again`)}`, value: "dismiss" },
+        ],
+    });
+    if (action === "skip") {
+        blank();
+        return;
+    }
+    if (action === "dismiss") {
+        dismissVersion(result.latestVersion);
+        blank();
+        return;
+    }
+    if (action === "update") {
+        blank();
+        info("Installing", `${CYAN(NPM_PACKAGE)}@${result.latestVersion}`);
+        divider();
+        const { execSync } = await import("node:child_process");
+        try {
+            execSync(`npm install -g ${NPM_PACKAGE}@latest`, { stdio: "inherit" });
+            blank();
+            success("Update complete!", `Now running ${result.latestVersion}. Please re-run your command.`);
+            blank();
+            process.exit(0);
+        }
+        catch {
+            error("Update failed.", "You can update manually: npm install -g @greenarmor/ges@latest");
+            blank();
+        }
+    }
+}

package/dist/utils/version.d.ts

@@ -1 +1,5 @@
 export declare const CLI_VERSION: string;
+export declare const AUTHOR: string;
+export declare const RELEASE_DATE: string;
+export declare const DONATE_URL: string;
+export declare const HOMEPAGE: string;

package/dist/utils/version.js

@@ -6,3 +6,7 @@ const __dirname = path.dirname(__filename);
 const require = createRequire(import.meta.url);
 const pkg = require(path.join(__dirname, "..", "..", "package.json"));
 export const CLI_VERSION = pkg.version;
+export const AUTHOR = "greenarmor";
+export const RELEASE_DATE = "2026-06-20";
+export const DONATE_URL = "https://ko-fi.com/greenarmor";
+export const HOMEPAGE = "https://github.com/greenarmor/gesf";

package/package.json

@@ -3,19 +3,19 @@
     "ges": "./dist/cli.js"
   },
   "dependencies": {
-    "@greenarmor/ges-audit-engine": "1.5.4",
-    "@greenarmor/ges-cicd-generator": "1.5.4",
-    "@greenarmor/ges-compliance-engine": "1.5.4",
-    "@greenarmor/ges-core": "1.5.4",
-    "@greenarmor/ges-doc-generator": "1.5.4",
-    "@greenarmor/ges-git-hooks": "1.5.4",
-    "@greenarmor/ges-mcp-server": "1.5.4",
-    "@greenarmor/ges-policy-engine": "1.5.4",
-    "@greenarmor/ges-report-generator": "1.5.4",
-    "@greenarmor/ges-rules-engine": "1.5.4",
-    "@greenarmor/ges-scanner-integration": "1.5.4",
-    "@greenarmor/ges-scoring-engine": "1.5.4",
-    "@greenarmor/ges-web-dashboard": "1.5.4",
+    "@greenarmor/ges-audit-engine": "1.5.5",
+    "@greenarmor/ges-cicd-generator": "1.5.5",
+    "@greenarmor/ges-compliance-engine": "1.5.5",
+    "@greenarmor/ges-core": "1.5.5",
+    "@greenarmor/ges-doc-generator": "1.5.5",
+    "@greenarmor/ges-git-hooks": "1.5.5",
+    "@greenarmor/ges-mcp-server": "1.5.5",
+    "@greenarmor/ges-policy-engine": "1.5.5",
+    "@greenarmor/ges-report-generator": "1.5.5",
+    "@greenarmor/ges-rules-engine": "1.5.5",
+    "@greenarmor/ges-scanner-integration": "1.5.5",
+    "@greenarmor/ges-scoring-engine": "1.5.5",
+    "@greenarmor/ges-web-dashboard": "1.5.5",
     "chalk": "^5.6.2",
     "commander": "^13.0.0"
   },
@@ -60,7 +60,7 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist tsconfig.tsbuildinfo",