@greenarmor/ges 1.5.3 → 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/governance.js

@@ -1,7 +1,7 @@
 import { Command } from "commander";
 import { ensureGESInitialized } from "../utils/project.js";
 import { input, select } from "../utils/prompts.js";
-import { banner, divider, blank, success, error, warn, info, kv, statusBadge, severityBadge, BOLD, DIM, GREEN, RED, YELLOW, GRAY, } from "../utils/ui.js";
+import { banner, divider, blank, success, error, warn, info, kv, label, statusBadge, severityBadge, BOLD, DIM, GREEN, RED, YELLOW, GRAY, } from "../utils/ui.js";
 import { loadGovernanceRecords, createGovernanceRecord, addGovernanceRecord, findGovernanceRecord, setGovernanceApproval, addGovernanceEvidence, createEvidenceRef, verifyGovernanceRecord, deleteGovernanceRecord, setGovernanceRiskAssessment, setGovernancePolicyBasis, setGovernanceReviewCycle, setGovernanceDataInventory, setGovernanceComplianceLinks, setGovernanceCommittee, } from "@greenarmor/ges-core";
 import { recordActivity } from "@greenarmor/ges-core";
 const STATUS_BADGE = {
@@ -32,6 +32,70 @@ function printRecordSummary(record) {
     }
     console.log(`     ${DIM("Ev")}     ${record.evidence.length} reference(s)`);
 }
+async function showGovernanceNextAction(root, records, lastShownId) {
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true)
+        return;
+    const choices = [];
+    if (lastShownId) {
+        choices.push({ name: `Verify this record ${DIM("— check provenance completeness")}`, value: `ges governance verify ${lastShownId}` });
+        if (records.length > 1) {
+            choices.push({ name: `Show another record ${DIM("— pick from list")}`, value: `__pick_show__` });
+        }
+        choices.push({ name: `Record an approval ${DIM("— add approval decision")}`, value: `ges governance approve ${lastShownId}` });
+        choices.push({ name: `Add evidence reference ${DIM("— link to Jira/Confluence/etc")}`, value: `ges governance evidence ${lastShownId}` });
+        choices.push({ name: `Link risk assessment ${DIM("— assessor, methodology, score")}`, value: `ges governance risk-assessment ${lastShownId}` });
+        choices.push({ name: `Document policy basis ${DIM("— which policy applies")}`, value: `ges governance policy-basis ${lastShownId}` });
+    }
+    else if (records.length > 0) {
+        choices.push({ name: `Show a record's full provenance chain ${DIM("— all dimensions in detail")}`, value: `__pick_show__` });
+        choices.push({ name: `Verify a record's completeness ${DIM("— check all 8 dimensions")}`, value: `__pick_verify__` });
+    }
+    choices.push({ name: `Create a new governance record ${DIM("— start a new approval chain")}`, value: `ges governance add` });
+    if (records.length === 0) {
+        choices.length = 0;
+        choices.push({ name: `Create a new governance record ${DIM("— start a new approval chain")}`, value: `ges governance add` });
+    }
+    choices.push({ name: `${YELLOW("Exit")} ${DIM("— return to terminal")}`, value: `exit` });
+    divider();
+    label("What would you like to do next?");
+    const answer = await select({
+        message: "Choose your next action:",
+        choices,
+    });
+    if (answer === "exit") {
+        blank();
+        return;
+    }
+    let cmd = answer;
+    if (answer === "__pick_show__" || answer === "__pick_verify__") {
+        let recordChoice;
+        if (records.length === 1) {
+            recordChoice = records[0].id;
+        }
+        else {
+            recordChoice = await select({
+                message: "Select a record:",
+                choices: records.map(r => ({
+                    name: `${r.system_name} ${GRAY(`(${r.status}, ${r.risk_level})`)}`,
+                    value: r.id,
+                })),
+            });
+        }
+        const sub = answer === "__pick_show__" ? "show" : "verify";
+        cmd = `ges governance ${sub} ${recordChoice}`;
+    }
+    blank();
+    info("Running", GREEN(cmd));
+    divider();
+    blank();
+    const { execSync } = await import("node:child_process");
+    try {
+        execSync(cmd, { stdio: "inherit" });
+    }
+    catch {
+        process.exit(1);
+    }
+}
 export const governanceCommand = new Command("governance")
     .description("Manage governance approval provenance chains")
     .action(async () => {
@@ -332,12 +396,13 @@ export const governanceCommand = new Command("governance")
 }))
     .addCommand(new Command("list")
     .description("List all governance records")
-    .action(() => {
+    .action(async () => {
     const root = ensureGESInitialized();
     const records = loadGovernanceRecords(root);
     if (records.length === 0) {
         info("No governance records found.");
         console.log(`  ${DIM("Create one with:")} ${GREEN("ges governance add")}\n`);
+        await showGovernanceNextAction(root, records);
         return;
     }
     blank();
@@ -347,11 +412,12 @@ export const governanceCommand = new Command("governance")
         printRecordSummary(r);
         console.log();
     });
+    await showGovernanceNextAction(root, records);
 }))
     .addCommand(new Command("show")
     .description("Show full provenance chain for a governance record")
     .argument("<id>", "Record ID or system name")
-    .action((id) => {
+    .action(async (id) => {
     const root = ensureGESInitialized();
     const record = findGovernanceRecord(root, id);
     if (!record) {
@@ -494,11 +560,12 @@ export const governanceCommand = new Command("governance")
     }
     console.log(`\n  Created: ${record.created_at} by ${record.created_by}`);
     console.log(`  Updated: ${record.updated_at} by ${record.updated_by} (v${record.record_version})\n`);
+    await showGovernanceNextAction(root, [record], record.id);
 }))
     .addCommand(new Command("verify")
     .description("Verify the provenance chain completeness of a governance record")
     .argument("<id>", "Record ID or system name")
-    .action((id) => {
+    .action(async (id) => {
     const root = ensureGESInitialized();
     const record = findGovernanceRecord(root, id);
     if (!record) {
@@ -543,6 +610,7 @@ export const governanceCommand = new Command("governance")
         result.warnings.forEach(w => console.log(`    ${YELLOW("△")} ${w}`));
     }
     console.log();
+    await showGovernanceNextAction(root, [record], record.id);
 }))
     .addCommand(new Command("delete")
     .description("Delete a governance record")

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.3",
-    "@greenarmor/ges-cicd-generator": "1.5.3",
-    "@greenarmor/ges-compliance-engine": "1.5.3",
-    "@greenarmor/ges-core": "1.5.3",
-    "@greenarmor/ges-doc-generator": "1.5.3",
-    "@greenarmor/ges-git-hooks": "1.5.3",
-    "@greenarmor/ges-mcp-server": "1.5.3",
-    "@greenarmor/ges-policy-engine": "1.5.3",
-    "@greenarmor/ges-report-generator": "1.5.3",
-    "@greenarmor/ges-rules-engine": "1.5.3",
-    "@greenarmor/ges-scanner-integration": "1.5.3",
-    "@greenarmor/ges-scoring-engine": "1.5.3",
-    "@greenarmor/ges-web-dashboard": "1.5.3",
+    "@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.3",
+  "version": "1.5.5",
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist tsconfig.tsbuildinfo",