@devkitvault/recall 1.2.9 → 1.2.10

package/README.md

@@ -25,17 +25,18 @@ recall doctor
 
 ## Quick start (local vault)
 
-Free is **fully local** — save / list / search / run on your machine with **no account**. Cloud **sync** and **Ask** are Pro/Team.
+Local save / list / search / run work **without an account**. Auth is only needed for **sync**, **Ask** (Pro/Team), and team features.
 
 ```sh
 recall save "docker compose up -d" --name docker --tags docker
 recall save --last -n useful -t docker
+recall import history
 recall list
 recall search docker
 recall run docker
 ```
 
-Commands live in `~/.recall/commands.json`.
+`recall import history` reads your shell history file (zsh/bash/PowerShell), lets you pick commands, and saves them locally. It does **not** install a keylogger or live hook.
 
 `recall save --last` (or `-L`) reads the last line from zsh / bash / PowerShell history. Not supported in Windows `cmd.exe`. On bash, if the command is missing: `history -a && recall save --last`.
 

package/dist/commands/import.js

@@ -7,19 +7,22 @@ exports.importCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const fs_1 = __importDefault(require("fs"));
-const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
 const path_1 = __importDefault(require("path"));
-const api_1 = require("../lib/api");
-const auth_1 = require("../lib/auth");
+const local_vault_1 = require("../lib/local-vault");
+const tags_1 = require("../lib/tags");
+const shell_history_1 = require("../lib/shell-history");
 function parseJSON(content) {
     const data = JSON.parse(content);
     if (!Array.isArray(data))
         throw new Error('JSON must be an array of commands');
     return data.map((item) => ({
-        command: item.command,
-        name: item.name,
-        tags: item.tags ?? [],
-    }));
+        command: String(item.command ?? ''),
+        name: typeof item.name === 'string' ? item.name : undefined,
+        tags: Array.isArray(item.tags)
+            ? item.tags.filter((t) => typeof t === 'string')
+            : undefined,
+    })).filter((e) => e.command.trim());
 }
 function parseSh(content) {
     const lines = content.split('\n');
@@ -28,14 +31,13 @@ function parseSh(content) {
     let currentTags = [];
     for (const raw of lines) {
         const line = raw.trim();
-        // skip empty lines and shebang
         if (!line || line.startsWith('#!'))
             continue;
         if (line.startsWith('# tags:')) {
             currentTags = line
                 .replace('# tags:', '')
                 .split(',')
-                .map(t => t.trim())
+                .map((t) => t.trim())
                 .filter(Boolean);
             continue;
         }
@@ -43,24 +45,59 @@ function parseSh(content) {
             currentName = line.replace('#', '').trim();
             continue;
         }
-        // it's a command
         entries.push({
             command: line,
             name: currentName,
-            tags: currentTags,
+            tags: currentTags.length ? currentTags : undefined,
         });
-        // reset
         currentName = undefined;
         currentTags = [];
     }
     return entries;
 }
-exports.importCommand = new commander_1.Command('import')
-    .description('Import commands from a JSON or shell script file')
-    .argument('<file>', 'Path to the file to import')
-    .option('-s, --skip-duplicates', 'Skip commands that already exist by name')
-    .action(async (file, opts) => {
-    const token = await (0, auth_1.requireAuth)();
+function commandAlreadyLocal(command, name) {
+    if (name && (0, local_vault_1.findLocalByName)(name))
+        return true;
+    return (0, local_vault_1.listLocalCommands)().some((c) => c.command === command);
+}
+function suggestName(command, used) {
+    const base = command
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .toLowerCase()
+        .slice(0, 32) || 'cmd';
+    let name = base;
+    let n = 2;
+    while (used.has(name) || (0, local_vault_1.findLocalByName)(name)) {
+        name = `${base.slice(0, 28)}-${n}`;
+        n++;
+    }
+    used.add(name);
+    return name;
+}
+async function importEntries(entries, opts) {
+    let imported = 0;
+    let skipped = 0;
+    const usedNames = new Set();
+    for (const entry of entries) {
+        if (opts.skipDuplicates && commandAlreadyLocal(entry.command, entry.name)) {
+            skipped++;
+            continue;
+        }
+        const name = entry.name
+            ?? (opts.nameThem ? suggestName(entry.command, usedNames) : undefined);
+        if (name)
+            usedNames.add(name);
+        (0, local_vault_1.saveLocalCommand)({
+            command: entry.command,
+            name,
+            tags: entry.tags,
+        });
+        imported++;
+    }
+    return { imported, skipped };
+}
+async function importFromFile(file, opts) {
     const filePath = path_1.default.resolve(file);
     if (!fs_1.default.existsSync(filePath)) {
         console.error(chalk_1.default.red(`\n  File not found: ${filePath}\n`));
@@ -77,7 +114,6 @@ exports.importCommand = new commander_1.Command('import')
             entries = parseSh(content);
         }
         else {
-            // try JSON first, then sh
             try {
                 entries = parseJSON(content);
             }
@@ -87,40 +123,114 @@ exports.importCommand = new commander_1.Command('import')
         }
     }
     catch (err) {
-        console.error(chalk_1.default.red(`\n  Failed to parse file: ${err.message}\n`));
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(chalk_1.default.red(`\n  Failed to parse file: ${message}\n`));
         process.exit(1);
     }
     if (!entries.length) {
         console.log(chalk_1.default.dim('\n  No commands found in file.\n'));
         return;
     }
-    console.log(chalk_1.default.dim(`\n  Found ${entries.length} command${entries.length === 1 ? '' : 's'} to import\n`));
-    let imported = 0;
-    let skipped = 0;
-    let failed = 0;
-    for (const entry of entries) {
-        const spinner = (0, ora_1.default)(`Importing: ${chalk_1.default.white(entry.name ?? entry.command.slice(0, 40))}`).start();
-        try {
-            await api_1.ApiClient.post('/commands', {
-                command: entry.command,
-                name: entry.name,
-                tags: entry.tags,
-            }, token);
-            spinner.succeed(chalk_1.default.green(`Imported: ${entry.name ?? entry.command.slice(0, 40)}`));
-            imported++;
-        }
-        catch (err) {
-            if (opts.skipDuplicates && err.status === 409) {
-                spinner.warn(chalk_1.default.yellow(`Skipped: ${entry.name ?? entry.command.slice(0, 40)}`));
-                skipped++;
-            }
-            else {
-                spinner.fail(chalk_1.default.red(`Failed: ${entry.name ?? entry.command.slice(0, 40)}`));
-                failed++;
-            }
+    console.log(chalk_1.default.dim(`\n  Found ${entries.length} command${entries.length === 1 ? '' : 's'} in file\n`));
+    const { imported, skipped } = await importEntries(entries, {
+        skipDuplicates: opts.skipDuplicates,
+        nameThem: false,
+    });
+    console.log(`  ${chalk_1.default.green(`${imported} imported`)}  ${chalk_1.default.yellow(`${skipped} skipped`)}`);
+    console.log(chalk_1.default.dim(`  Vault: ${local_vault_1.VAULT_FILE}\n`));
+}
+exports.importCommand = new commander_1.Command('import')
+    .description('Import commands into your local vault')
+    .argument('[file]', 'JSON or shell script to import (or use: recall import history)')
+    .option('-s, --skip-duplicates', 'Skip commands that already exist locally', true)
+    .addHelpText('after', `
+Examples:
+  $ recall import history
+  $ recall import history -n 20 -y
+  $ recall import ./backup.json
+`)
+    .action(async (file, opts) => {
+    if (!file) {
+        console.log(chalk_1.default.dim('\n  Usage:'));
+        console.log(chalk_1.default.dim('    recall import history     # from shell history (curated)'));
+        console.log(chalk_1.default.dim('    recall import <file>      # from JSON or .sh\n'));
+        process.exit(1);
+    }
+    await importFromFile(file, opts);
+});
+exports.importCommand
+    .command('history')
+    .description('Import curated commands from shell history into the local vault (not live capture)')
+    .option('-n, --limit <count>', 'Max unique recent commands to consider', '40')
+    .option('-y, --yes', 'Import all candidates without prompting')
+    .option('-i, --interactive', 'Choose which commands to import (default unless --yes)')
+    .option('--dry-run', 'Show candidates only; do not write')
+    .option('-t, --tags <tags>', 'Tags applied to imported commands')
+    .option('--min-length <n>', 'Skip commands shorter than this', '3')
+    .option('--no-names', 'Do not auto-generate names')
+    .option('--no-skip-duplicates', 'Import even if the same command text already exists')
+    .action(async (opts) => {
+    const limit = Math.max(1, parseInt(String(opts.limit), 10) || 40);
+    const minLength = Math.max(1, parseInt(String(opts.minLength), 10) || 3);
+    const tags = (0, tags_1.parseTags)(opts.tags);
+    let commands;
+    let source;
+    let shell;
+    try {
+        const result = (0, shell_history_1.readHistoryCommands)({ limit, minLength });
+        commands = result.commands;
+        source = result.source;
+        shell = result.shell;
+    }
+    catch (err) {
+        if (err instanceof shell_history_1.LastCommandError) {
+            console.log(chalk_1.default.red(`\n  ${err.message}\n`));
+            process.exit(1);
         }
+        throw err;
     }
     console.log();
-    console.log(`  ${chalk_1.default.green(`${imported} imported`)}  ${chalk_1.default.yellow(`${skipped} skipped`)}  ${chalk_1.default.red(`${failed} failed`)}`);
+    console.log(chalk_1.default.dim(`  Shell: ${shell} · ${source}`));
+    console.log(chalk_1.default.dim(`  ${commands.length} unique candidate${commands.length === 1 ? '' : 's'} (newest first)\n`));
+    let selected = commands;
+    const interactive = !opts.yes && (opts.interactive || !opts.dryRun);
+    if (opts.yes) {
+        selected = commands;
+    }
+    else if (interactive && !opts.dryRun) {
+        const { picked } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'picked',
+                message: 'Select commands to save locally',
+                pageSize: 16,
+                choices: commands.map((c) => ({
+                    name: c.length > 80 ? `${c.slice(0, 77)}…` : c,
+                    value: c,
+                    checked: false,
+                })),
+            },
+        ]);
+        selected = picked;
+        if (!selected.length) {
+            console.log(chalk_1.default.dim('\n  Nothing selected.\n'));
+            return;
+        }
+    }
+    if (opts.dryRun) {
+        for (const [i, c] of selected.entries()) {
+            console.log(`  ${chalk_1.default.dim(String(i + 1).padStart(2))}. ${c}`);
+        }
+        console.log(chalk_1.default.dim(`\n  Dry run — nothing written. Drop --dry-run to import.\n`));
+        return;
+    }
+    const entries = selected.map((command) => ({ command, tags }));
+    const { imported, skipped } = await importEntries(entries, {
+        skipDuplicates: opts.skipDuplicates !== false,
+        nameThem: opts.names !== false,
+    });
     console.log();
+    console.log(`  ${chalk_1.default.green(`${imported} imported`)}  ${chalk_1.default.yellow(`${skipped} skipped`)}`);
+    console.log(chalk_1.default.dim(`  Vault: ${local_vault_1.VAULT_FILE}`));
+    console.log(chalk_1.default.dim('  Sync to cloud (Pro): recall sync\n'));
 });

package/dist/lib/config.js

@@ -11,7 +11,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.recall');
 const CONFIG_FILE = path_1.default.join(CONFIG_DIR, 'config.json');
-exports.APP_VERSION = '1.2.9';
+exports.APP_VERSION = '1.2.10';
 exports.ENVIRONMENTS = {
     production: 'https://api.devkitvault.com',
     local: 'http://127.0.0.1:3001',

package/dist/lib/shell-history.js

@@ -5,6 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (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;
@@ -19,6 +23,96 @@ 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+;(.*)$/);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devkitvault/recall",
-  "version": "1.2.9",
+  "version": "1.2.10",
   "description": "recall CLI — personal command vault for your terminal (local-first)",
   "keywords": [
     "cli",