@devkitvault/recall 1.2.7 → 1.2.10

package/dist/lib/local-vault.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VAULT_FILE = void 0;
+exports.readVault = readVault;
+exports.writeVault = writeVault;
+exports.listLocalCommands = listLocalCommands;
+exports.findLocalByName = findLocalByName;
+exports.saveLocalCommand = saveLocalCommand;
+exports.deleteLocalByName = deleteLocalByName;
+exports.setLocalPinned = setLocalPinned;
+exports.markVaultSynced = markVaultSynced;
+exports.replaceLocalFromCloud = replaceLocalFromCloud;
+exports.mergeCloudIntoLocal = mergeCloudIntoLocal;
+exports.localCommandsNeedingPush = localCommandsNeedingPush;
+exports.attachCloudId = attachCloudId;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const VAULT_DIR = node_path_1.default.join(process.env.RECALL_HOME?.trim() || node_os_1.default.homedir(), '.recall');
+exports.VAULT_FILE = node_path_1.default.join(VAULT_DIR, 'commands.json');
+function nowIso() {
+    return new Date().toISOString();
+}
+function ensureDir() {
+    node_fs_1.default.mkdirSync(VAULT_DIR, { recursive: true });
+}
+function normalizeCommand(raw, legacySyncCache) {
+    const command = String(raw.command ?? '');
+    const name = typeof raw.name === 'string' && raw.name.trim() ? raw.name.trim() : undefined;
+    const tags = Array.isArray(raw.tags)
+        ? raw.tags.filter((t) => typeof t === 'string' && t.trim().length > 0)
+        : undefined;
+    const pinned = Boolean(raw.pinned);
+    const createdAt = typeof raw.createdAt === 'string' ? raw.createdAt : nowIso();
+    const updatedAt = typeof raw.updatedAt === 'string' ? raw.updatedAt : createdAt;
+    let cloudId;
+    if (typeof raw.cloudId === 'string' && raw.cloudId) {
+        cloudId = raw.cloudId;
+    }
+    else if (legacySyncCache && typeof raw.id === 'string' && raw.id) {
+        // Old cache used API ids as `id`
+        cloudId = raw.id;
+    }
+    const id = !legacySyncCache && typeof raw.id === 'string' && raw.id
+        ? raw.id
+        : (0, node_crypto_1.randomUUID)();
+    return {
+        id,
+        command,
+        name,
+        tags: tags?.length ? tags : undefined,
+        pinned: pinned || undefined,
+        createdAt,
+        updatedAt,
+        cloudId,
+    };
+}
+function emptyVault() {
+    return {
+        version: 1,
+        updatedAt: nowIso(),
+        syncedAt: null,
+        commands: [],
+    };
+}
+function readVault() {
+    try {
+        if (!node_fs_1.default.existsSync(exports.VAULT_FILE))
+            return emptyVault();
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(exports.VAULT_FILE, 'utf-8'));
+        const rawCommands = Array.isArray(parsed.commands) ? parsed.commands : [];
+        const legacySyncCache = parsed.version !== 1;
+        const commands = rawCommands
+            .filter((c) => c !== null && typeof c === 'object')
+            .map((c) => normalizeCommand(c, legacySyncCache))
+            .filter((c) => c.command.trim().length > 0);
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : nowIso(),
+            syncedAt: typeof parsed.syncedAt === 'string' ? parsed.syncedAt : null,
+            commands,
+        };
+    }
+    catch {
+        return emptyVault();
+    }
+}
+function writeVault(vault) {
+    ensureDir();
+    const payload = {
+        version: 1,
+        updatedAt: nowIso(),
+        syncedAt: vault.syncedAt ?? null,
+        commands: vault.commands,
+    };
+    node_fs_1.default.writeFileSync(exports.VAULT_FILE, JSON.stringify(payload, null, 2), { mode: 0o600 });
+}
+function listLocalCommands(filters) {
+    let rows = readVault().commands;
+    if (filters?.tag) {
+        const tag = filters.tag.toLowerCase();
+        rows = rows.filter((c) => (c.tags ?? []).some((t) => t.toLowerCase() === tag));
+    }
+    if (filters?.search) {
+        const q = filters.search.toLowerCase();
+        rows = rows.filter((c) => c.command.toLowerCase().includes(q) ||
+            (c.name?.toLowerCase().includes(q) ?? false) ||
+            (c.tags ?? []).some((t) => t.toLowerCase().includes(q)));
+    }
+    if (filters?.pinned) {
+        rows = rows.filter((c) => c.pinned);
+    }
+    return rows.sort((a, b) => {
+        if (a.pinned && !b.pinned)
+            return -1;
+        if (!a.pinned && b.pinned)
+            return 1;
+        return b.updatedAt.localeCompare(a.updatedAt);
+    });
+}
+function findLocalByName(name) {
+    const needle = name.toLowerCase();
+    return readVault().commands.find((c) => c.name?.toLowerCase() === needle);
+}
+function saveLocalCommand(input) {
+    const vault = readVault();
+    const stamp = nowIso();
+    const name = input.name?.trim() || undefined;
+    if (name) {
+        const existing = vault.commands.find((c) => c.name?.toLowerCase() === name.toLowerCase());
+        if (existing) {
+            existing.command = input.command;
+            existing.tags = input.tags?.length ? input.tags : undefined;
+            existing.updatedAt = stamp;
+            // Local edit invalidates cloud link until next push maps again
+            writeVault(vault);
+            return existing;
+        }
+    }
+    const saved = {
+        id: (0, node_crypto_1.randomUUID)(),
+        command: input.command,
+        name,
+        tags: input.tags?.length ? input.tags : undefined,
+        createdAt: stamp,
+        updatedAt: stamp,
+    };
+    vault.commands.push(saved);
+    writeVault(vault);
+    return saved;
+}
+function deleteLocalByName(name) {
+    const vault = readVault();
+    const idx = vault.commands.findIndex((c) => c.name?.toLowerCase() === name.toLowerCase());
+    if (idx < 0)
+        return undefined;
+    const [removed] = vault.commands.splice(idx, 1);
+    writeVault(vault);
+    return removed;
+}
+function setLocalPinned(name, pinned) {
+    const vault = readVault();
+    const cmd = vault.commands.find((c) => c.name?.toLowerCase() === name.toLowerCase());
+    if (!cmd)
+        return undefined;
+    cmd.pinned = pinned || undefined;
+    cmd.updatedAt = nowIso();
+    writeVault(vault);
+    return cmd;
+}
+function markVaultSynced(at = nowIso()) {
+    const vault = readVault();
+    vault.syncedAt = at;
+    writeVault(vault);
+}
+function replaceLocalFromCloud(cloudCommands) {
+    const stamp = nowIso();
+    const mapped = cloudCommands.map((c) => ({
+        id: (0, node_crypto_1.randomUUID)(),
+        cloudId: c.id,
+        command: c.command,
+        name: c.name ?? undefined,
+        tags: c.tags?.length ? c.tags : undefined,
+        pinned: c.pinned || undefined,
+        createdAt: c.createdAt ?? stamp,
+        updatedAt: c.updatedAt ?? stamp,
+    }));
+    writeVault({
+        version: 1,
+        updatedAt: stamp,
+        syncedAt: stamp,
+        commands: mapped,
+    });
+    return mapped;
+}
+/** Merge cloud into local by name (cloud wins on conflict); keep local-only rows. */
+function mergeCloudIntoLocal(cloudCommands) {
+    const vault = readVault();
+    const stamp = nowIso();
+    let added = 0;
+    let updated = 0;
+    for (const cloud of cloudCommands) {
+        const name = cloud.name?.trim();
+        const byCloudId = vault.commands.find((c) => c.cloudId === cloud.id);
+        const byName = name
+            ? vault.commands.find((c) => c.name?.toLowerCase() === name.toLowerCase())
+            : undefined;
+        const target = byCloudId ?? byName;
+        if (target) {
+            target.cloudId = cloud.id;
+            target.command = cloud.command;
+            target.name = name || target.name;
+            target.tags = cloud.tags?.length ? cloud.tags : undefined;
+            target.pinned = cloud.pinned || undefined;
+            target.updatedAt = stamp;
+            updated++;
+        }
+        else {
+            vault.commands.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                cloudId: cloud.id,
+                command: cloud.command,
+                name: name || undefined,
+                tags: cloud.tags?.length ? cloud.tags : undefined,
+                pinned: cloud.pinned || undefined,
+                createdAt: cloud.createdAt ?? stamp,
+                updatedAt: stamp,
+            });
+            added++;
+        }
+    }
+    vault.syncedAt = stamp;
+    writeVault(vault);
+    return { local: vault.commands, added, updated };
+}
+function localCommandsNeedingPush() {
+    return readVault().commands.filter((c) => !c.cloudId);
+}
+function attachCloudId(localId, cloudId) {
+    const vault = readVault();
+    const cmd = vault.commands.find((c) => c.id === localId);
+    if (!cmd)
+        return;
+    cmd.cloudId = cloudId;
+    cmd.updatedAt = nowIso();
+    writeVault(vault);
+}

package/dist/lib/shell-history.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LastCommandError = void 0;
+exports.isSelfSaveCommand = isSelfSaveCommand;
+exports.isSkippedHistoryCommand = isSkippedHistoryCommand;
+exports.normalizeHistoryLine = normalizeHistoryLine;
+exports.extractSaveableCommands = extractSaveableCommands;
+exports.readHistoryCommands = readHistoryCommands;
+exports.stripZshExtendedPrefix = stripZshExtendedPrefix;
+exports.findLastSaveableCommand = findLastSaveableCommand;
+exports.detectShellKind = detectShellKind;
+exports.historyFileCandidates = historyFileCandidates;
+exports.readLastCommandFromHistoryFile = readLastCommandFromHistoryFile;
+exports.getLastShellCommand = getLastShellCommand;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+/** True if this history line is a recall/rec save invocation (skip so we don't save ourselves). */
+function isSelfSaveCommand(line) {
+    const t = line.trim();
+    return /^(recall|rec)\s+save(\s|$)/.test(t);
+}
+/** Skip trivial / meta lines when bulk-importing history. */
+function isSkippedHistoryCommand(line) {
+    const t = line.trim();
+    if (!t)
+        return true;
+    if (isSelfSaveCommand(t))
+        return true;
+    if (/^(recall|rec)(\s|$)/.test(t))
+        return true;
+    if (t.length < 2)
+        return true;
+    const first = t.split(/\s+/)[0]?.toLowerCase() ?? '';
+    const trivial = new Set([
+        'cd', 'ls', 'll', 'la', 'pwd', 'clear', 'cls', 'exit', 'logout',
+        'history', 'true', 'false', ':',
+    ]);
+    if (trivial.has(first) && t.split(/\s+/).length <= 2)
+        return true;
+    return false;
+}
+/** Normalize one history file line into a bare command, or null if not usable. */
+function normalizeHistoryLine(rawLine) {
+    let raw = rawLine.replace(/\r$/, '');
+    if (!raw.trim())
+        return null;
+    if (/^#\d+$/.test(raw.trim()))
+        return null;
+    raw = stripZshExtendedPrefix(raw).trim();
+    if (!raw)
+        return null;
+    return raw;
+}
+/**
+ * Walk history lines (oldest → newest) and return unique saveable commands, newest first.
+ */
+function extractSaveableCommands(lines, opts = {}) {
+    const minLength = opts.minLength ?? 3;
+    const seen = new Set();
+    const out = [];
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const cmd = normalizeHistoryLine(lines[i] ?? '');
+        if (!cmd)
+            continue;
+        if (cmd.length < minLength)
+            continue;
+        if (isSkippedHistoryCommand(cmd))
+            continue;
+        if (seen.has(cmd))
+            continue;
+        seen.add(cmd);
+        out.push(cmd);
+        if (opts.limit !== undefined && out.length >= opts.limit)
+            break;
+    }
+    return out;
+}
+function readHistoryCommands(opts = {}) {
+    const env = opts.env ?? process.env;
+    const platform = opts.platform ?? process.platform;
+    const home = opts.home ?? os_1.default.homedir();
+    const shell = detectShellKind(env, platform);
+    if (shell === 'cmd') {
+        throw new LastCommandError('import history is not supported in cmd.exe. Use PowerShell, Git Bash, or WSL.', 'unsupported');
+    }
+    if (shell === 'unknown') {
+        throw new LastCommandError('Could not detect your shell. Use zsh, bash, or PowerShell.', 'unsupported');
+    }
+    const files = historyFileCandidates(shell, env, home);
+    for (const file of files) {
+        try {
+            if (!fs_1.default.existsSync(file))
+                continue;
+            const text = fs_1.default.readFileSync(file, 'utf8');
+            const commands = extractSaveableCommands(text.split('\n'), {
+                limit: opts.limit,
+                minLength: opts.minLength,
+            });
+            if (commands.length) {
+                return { commands, source: file, shell };
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    const tip = shell === 'bash'
+        ? ' If history looks empty, try: history -a && recall import history'
+        : '';
+    throw new LastCommandError(`No importable commands found in shell history.${tip}`, 'not_found');
+}
+/** Strip zsh extended-history prefix `: <unix>:<duration>;`. */
+function stripZshExtendedPrefix(line) {
+    const m = line.match(/^:\s*\d+:\d+;(.*)$/);
+    return m ? m[1] : line;
+}
+/**
+ * Walk history lines newest-first and return the first saveable command.
+ * Caller should pass lines in file order (oldest → newest); we scan from the end.
+ */
+function findLastSaveableCommand(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let raw = lines[i]?.replace(/\r$/, '') ?? '';
+        if (!raw.trim())
+            continue;
+        // bash HISTTIMEFORMAT lines are comments starting with #
+        if (/^#\d+$/.test(raw.trim()))
+            continue;
+        raw = stripZshExtendedPrefix(raw).trim();
+        if (!raw)
+            continue;
+        if (isSelfSaveCommand(raw))
+            continue;
+        return raw;
+    }
+    return null;
+}
+function detectShellKind(env = process.env, platform = process.platform) {
+    if (platform === 'win32') {
+        const shell = (env.SHELL || env.ComSpec || '').toLowerCase();
+        if (shell.includes('powershell') || shell.includes('pwsh'))
+            return 'powershell';
+        // Windows Terminal / VS Code often set PSModulePath when in PowerShell
+        if (env.PSModulePath && !shell.includes('cmd.exe')) {
+            if (env.TERM_PROGRAM || env.WT_SESSION || env.VSCODE_INJECTION) {
+                // Prefer PowerShell when clearly in a modern host without bash
+                if (!shell.includes('bash') && !shell.includes('zsh'))
+                    return 'powershell';
+            }
+        }
+        if (shell.includes('bash') || shell.includes('zsh')) {
+            return shell.includes('zsh') ? 'zsh' : 'bash';
+        }
+        if (shell.includes('cmd.exe') || shell.endsWith('\\cmd'))
+            return 'cmd';
+        // Default Windows: PowerShell is the intended path; cmd is unsupported
+        if (!env.SHELL)
+            return 'powershell';
+        return 'cmd';
+    }
+    const shell = (env.SHELL || '').toLowerCase();
+    if (shell.includes('zsh'))
+        return 'zsh';
+    if (shell.includes('bash'))
+        return 'bash';
+    if (shell.includes('pwsh') || shell.includes('powershell'))
+        return 'powershell';
+    return 'unknown';
+}
+function historyFileCandidates(kind, env = process.env, home = os_1.default.homedir()) {
+    if (env.HISTFILE)
+        return [env.HISTFILE];
+    switch (kind) {
+        case 'zsh':
+            return [path_1.default.join(home, '.zsh_history')];
+        case 'bash':
+            return [path_1.default.join(home, '.bash_history')];
+        case 'powershell': {
+            const candidates = [];
+            if (env.APPDATA) {
+                candidates.push(path_1.default.join(env.APPDATA, 'Microsoft', 'Windows', 'PowerShell', 'PSReadLine', 'ConsoleHost_history.txt'), path_1.default.join(env.APPDATA, 'Microsoft', 'PowerShell', 'PSReadLine', 'ConsoleHost_history.txt'));
+            }
+            candidates.push(path_1.default.join(home, '.local', 'share', 'powershell', 'PSReadLine', 'ConsoleHost_history.txt'), path_1.default.join(home, 'AppData', 'Roaming', 'Microsoft', 'Windows', 'PowerShell', 'PSReadLine', 'ConsoleHost_history.txt'));
+            return candidates;
+        }
+        default:
+            return [];
+    }
+}
+function readLastCommandFromHistoryFile(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return null;
+    const text = fs_1.default.readFileSync(filePath, 'utf8');
+    const lines = text.split('\n');
+    return findLastSaveableCommand(lines);
+}
+class LastCommandError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'LastCommandError';
+    }
+}
+exports.LastCommandError = LastCommandError;
+/**
+ * Resolve the last typed shell command from on-disk history.
+ * Same-session works when the shell appends history as you go (typical zsh / PSReadLine).
+ * Bash may need `history -a` first if the file is stale.
+ */
+function getLastShellCommand(env = process.env, platform = process.platform, home = os_1.default.homedir()) {
+    const shell = detectShellKind(env, platform);
+    if (shell === 'cmd') {
+        throw new LastCommandError('save --last is not supported in cmd.exe. Use PowerShell, Git Bash, or WSL — or paste the command: recall save "your command"', 'unsupported');
+    }
+    if (shell === 'unknown') {
+        throw new LastCommandError('Could not detect your shell. Use zsh, bash, or PowerShell — or paste the command: recall save "your command"', 'unsupported');
+    }
+    const files = historyFileCandidates(shell, env, home);
+    for (const file of files) {
+        try {
+            const command = readLastCommandFromHistoryFile(file);
+            if (command) {
+                return { command, source: file, shell };
+            }
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    const tip = shell === 'bash'
+        ? ' If you just ran the command in this session, try: history -a && recall save --last'
+        : '';
+    throw new LastCommandError(`No previous command found in shell history.${tip}`, 'not_found');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devkitvault/recall",
-  "version": "1.2.7",
-  "description": "recall CLI — AI terminal copilot with a personal command vault",
+  "version": "1.2.10",
+  "description": "recall CLI — personal command vault for your terminal (local-first)",
   "keywords": [
     "cli",
     "shell",
@@ -19,12 +19,11 @@
   "license": "MIT",
   "homepage": "https://recall.devkitvault.com",
   "bugs": {
-    "url": "https://github.com/devkitvault/recall/issues"
+    "url": "https://github.com/devkitvault/recall-cli/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/devkitvault/recall.git",
-    "directory": "packages/npm-cli"
+    "url": "git+https://github.com/devkitvault/recall-cli.git"
   },
     "bin": {
         "recall": "dist/index.js",