archive-labs 0.1.0

package/dist/recentHistory.js

@@ -0,0 +1,205 @@
+import crypto from "node:crypto";
+import { access, chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export const recentHistoryVersion = 1;
+export const defaultRecentCommandLimit = 10;
+export const maxRecentHistoryItems = 50;
+export const launcherRecentLimit = 3;
+export const historyDir = path.join(os.homedir(), ".archive-labs");
+export const historyPath = path.join(historyDir, "history.json");
+const fileExists = async (targetPath) => {
+    try {
+        await access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const normalizeTimestamp = (value) => {
+    if (typeof value !== "string" || !value.trim()) {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : null;
+};
+const normalizeCommandStatus = (value) => value === "error" ? "error" : "success";
+const normalizeCommandSource = (value) => value === "launcher" ? "launcher" : "cli";
+const normalizeCommandGroupValue = (value) => {
+    switch (value) {
+        case "setup":
+        case "system":
+        case "check":
+        case "impact":
+        case "intelligence":
+        case "release":
+        case "utility":
+            return value;
+        default:
+            return undefined;
+    }
+};
+const sanitizeHistoryItem = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const candidate = value;
+    const argv = Array.isArray(candidate.argv)
+        ? candidate.argv.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : [];
+    const command = typeof candidate.command === "string" && candidate.command.trim() ? candidate.command.trim() : null;
+    const cwd = typeof candidate.cwd === "string" && candidate.cwd.trim() ? path.resolve(candidate.cwd) : null;
+    const id = typeof candidate.id === "string" && candidate.id.trim() ? candidate.id.trim() : null;
+    const timestamp = normalizeTimestamp(candidate.timestamp);
+    if (!id || !command || !cwd || !timestamp || argv.length === 0) {
+        return null;
+    }
+    return {
+        id,
+        argv,
+        branch: typeof candidate.branch === "string" && candidate.branch.trim() ? candidate.branch.trim() : null,
+        command,
+        ...(normalizeCommandGroupValue(candidate.commandGroup) ? { commandGroup: normalizeCommandGroupValue(candidate.commandGroup) } : {}),
+        cwd,
+        durationMs: typeof candidate.durationMs === "number" && Number.isFinite(candidate.durationMs)
+            ? Math.max(0, Math.round(candidate.durationMs))
+            : 0,
+        exitCode: typeof candidate.exitCode === "number" && Number.isFinite(candidate.exitCode)
+            ? Math.round(candidate.exitCode)
+            : 0,
+        repository: typeof candidate.repository === "string" && candidate.repository.trim() ? candidate.repository.trim() : null,
+        rerunnable: candidate.rerunnable !== false,
+        source: normalizeCommandSource(candidate.source),
+        status: normalizeCommandStatus(candidate.status),
+        timestamp,
+    };
+};
+const quoteShellArg = (value) => (/[\s"]/u.test(value) ? JSON.stringify(value) : value);
+const normalizeRepository = (value) => (value?.trim().toLowerCase() ? value.trim().toLowerCase() : null);
+const compareRecency = (left, right) => (Date.parse(right.timestamp) || 0) - (Date.parse(left.timestamp) || 0);
+export const normalizeHistoryCwd = (cwd) => path.resolve(cwd);
+export const inferCommandGroup = (argv) => {
+    const [head = "", next = ""] = argv.map((entry) => entry.trim().toLowerCase());
+    if (head === "init" || head === "sync") {
+        return "setup";
+    }
+    if (head === "status" || head === "events") {
+        return "system";
+    }
+    if (head === "check") {
+        return "check";
+    }
+    if (head === "impact") {
+        return "impact";
+    }
+    if (head === "ask" || head === "why") {
+        return "intelligence";
+    }
+    if (head === "release") {
+        return "release";
+    }
+    if (head === "login" || head === "doctor" || head === "ping" || head === "help" || head === "version" || head === "recent") {
+        return "utility";
+    }
+    if (!head && next) {
+        return inferCommandGroup([next]);
+    }
+    return undefined;
+};
+export const shouldSkipHistoryArgv = (argv) => {
+    const tokens = argv
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return true;
+    }
+    const [head] = tokens;
+    if (head === "recent" || head === "help" || head === "version") {
+        return true;
+    }
+    return tokens.some((token) => /^__archive_internal/i.test(token) ||
+        /\/auth\/callback/i.test(token) ||
+        /\bcli_(state|port)\b/i.test(token));
+};
+export const formatHistoryCommand = (argv) => ["archive", ...argv].map(quoteShellArg).join(" ");
+export const createRecentHistoryItem = (input) => {
+    const argv = input.argv.map((entry) => String(entry));
+    const commandGroup = inferCommandGroup(argv);
+    return {
+        id: crypto.randomUUID(),
+        argv,
+        branch: input.branch?.trim() ? input.branch.trim() : null,
+        command: formatHistoryCommand(argv),
+        ...(commandGroup ? { commandGroup } : {}),
+        cwd: normalizeHistoryCwd(input.cwd),
+        durationMs: typeof input.durationMs === "number" && Number.isFinite(input.durationMs)
+            ? Math.max(0, Math.round(input.durationMs))
+            : 0,
+        exitCode: typeof input.exitCode === "number" && Number.isFinite(input.exitCode) ? Math.round(input.exitCode) : 0,
+        repository: input.repository?.trim() ? input.repository.trim() : null,
+        rerunnable: input.rerunnable !== false,
+        source: input.source ?? "cli",
+        status: input.status ?? "success",
+        timestamp: normalizeTimestamp(input.timestamp) ?? new Date().toISOString(),
+    };
+};
+export const loadRecentHistory = async (targetPath = historyPath) => {
+    if (!(await fileExists(targetPath))) {
+        return [];
+    }
+    try {
+        const raw = await readFile(targetPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const items = Array.isArray(parsed?.items)
+            ? parsed.items.map(sanitizeHistoryItem).filter((item) => Boolean(item))
+            : [];
+        return items.sort(compareRecency);
+    }
+    catch {
+        return [];
+    }
+};
+export const writeRecentHistory = async (items, targetPath = historyPath) => {
+    const normalizedItems = [...items].sort(compareRecency).slice(0, maxRecentHistoryItems);
+    await mkdir(path.dirname(targetPath), { mode: 0o700, recursive: true });
+    const payload = {
+        items: normalizedItems,
+        version: recentHistoryVersion,
+    };
+    await writeFile(targetPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    if (process.platform !== "win32") {
+        await Promise.allSettled([chmod(path.dirname(targetPath), 0o700), chmod(targetPath, 0o600)]);
+    }
+};
+export const appendRecentHistory = async (item, targetPath = historyPath) => {
+    const existing = await loadRecentHistory(targetPath);
+    await writeRecentHistory([item, ...existing], targetPath);
+};
+export const buildLauncherRecentEntries = (items, context = {}, limit = launcherRecentLimit) => {
+    const normalizedCwd = context.cwd ? normalizeHistoryCwd(context.cwd) : null;
+    const normalizedRepository = normalizeRepository(context.repository);
+    return items
+        .filter((item) => item.rerunnable)
+        .map((item) => {
+        let rank = 0;
+        if (normalizedCwd && normalizeHistoryCwd(item.cwd) === normalizedCwd) {
+            rank = 2;
+        }
+        else if (normalizedRepository && normalizeRepository(item.repository) === normalizedRepository) {
+            rank = 1;
+        }
+        return {
+            item,
+            rank,
+        };
+    })
+        .sort((left, right) => {
+        if (right.rank !== left.rank) {
+            return right.rank - left.rank;
+        }
+        return compareRecency(left.item, right.item);
+    })
+        .slice(0, Math.max(0, Math.floor(limit)))
+        .map((entry) => entry.item);
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "archive-labs",
+  "version": "0.1.0",
+  "description": "Archive Labs CLI",
+  "license": "MIT",
+  "preferGlobal": true,
+  "packageManager": "pnpm@10.33.0",
+  "type": "module",
+  "bin": {
+    "archive": "./dist/cli.js",
+    "archive-labs": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx watch src/cli.ts",
+    "start": "node dist/cli.js",
+    "smoke": "node dist/cli.js version && node dist/cli.js help",
+    "pack:verify": "node scripts/verify-pack.mjs",
+    "lint": "npm run typecheck",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:integration": "npm run build && node scripts/run-node-tests.mjs",
+    "test": "npm run test:integration",
+    "ci": "npm run clean && npm run typecheck && npm run build && npm run smoke && npm run test",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run ci"
+  },
+  "keywords": [
+    "archive-labs",
+    "archive",
+    "cli"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.16.5",
+    "tsx": "^4.20.3",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "listr2": "^10.2.1",
+    "ora": "^9.3.0"
+  }
+}