@havocrao/picktui 0.1.0 → 0.1.1

package/dist/esm/confirm.js

@@ -1,24 +1,95 @@
 /**
- * confirm — 自动匹配首次确认（文件状态，直调引擎 confirm 子命令）。
+ * confirm — 自动匹配的首次用户确认记录（confirm.toml）。
  *
- * 状态文件位于引擎数据目录，与 pick --auto 的确认记录同一份：
- * 首次自动匹配某 (label, value) 需确认，确认后不再询问。
+ * 文件格式与 Go 引擎 BurntSushi/toml 输出完全兼容：
+ *
+ *	# picktui confirm — user-confirmed auto resolutions (auto-managed)
+ *	[confirmed]
+ *	"npm run" = ["release", "dev"]
+ *
+ * label 为空时不做任何落盘（返回 false）。文件不存在或损坏 → 空记录
+ * （确认记录只是安全辅助，缺失最多导致首次匹配再次询问）。
  */
-import { assertSuccess, invokeEngine, parseJSON } from './engine.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { dataDir } from './config.js';
+import { parseToml, escapeTomlString, keyLiteral } from './toml.js';
+import { PicktuiError } from './types.js';
+/** 自动匹配确认记录文件名。 */
+export const CONFIRM_FILE = 'confirm.toml';
+/** 注释头（对齐引擎输出）。 */
+const HEADER = '# picktui confirm — user-confirmed auto resolutions (auto-managed)';
+/** 返回确认记录文件路径。 */
+export function confirmPath() {
+    return join(dataDir(), CONFIRM_FILE);
+}
+/** 解码 confirm.toml 为 label → 已确认值列表；缺失/损坏时返回空 Map。 */
+export function loadConfirmed() {
+    const p = confirmPath();
+    if (!existsSync(p)) {
+        return new Map();
+    }
+    const doc = parseToml(readFileSync(p, 'utf8'));
+    if (doc === null) {
+        return new Map();
+    }
+    const confirmed = doc.get('confirmed');
+    if (!confirmed) {
+        return new Map();
+    }
+    const out = new Map();
+    for (const [label, values] of confirmed) {
+        if (Array.isArray(values)) {
+            out.set(label, values.map(String));
+        }
+    }
+    return out;
+}
+/** 报告 (label, value) 是否已被确认过；label 为空时恒为 false。 */
+export function isConfirmed(label, value) {
+    if (label === '') {
+        return false;
+    }
+    return (loadConfirmed().get(label) ?? []).includes(value);
+}
+/** 记录 (label, value) 为已确认（幂等；label 为空不落盘）。 */
+export function confirm(label, value) {
+    if (label === '') {
+        return;
+    }
+    const m = loadConfirmed();
+    const list = m.get(label) ?? [];
+    if (list.includes(value)) {
+        return;
+    }
+    list.push(value);
+    m.set(label, list);
+    const lines = [HEADER, '[confirmed]'];
+    const labels = [...m.keys()].sort();
+    for (const l of labels) {
+        const values = (m.get(l) ?? []).map(escapeTomlString).map((v) => `"${v}"`);
+        lines.push(`${keyLiteral(l)} = [${values.join(', ')}]`);
+    }
+    const p = confirmPath();
+    try {
+        mkdirSync(dirname(p), { recursive: true });
+        writeFileSync(p, lines.join('\n') + '\n', { mode: 0o644 });
+    }
+    catch (err) {
+        throw new PicktuiError(`写入确认记录失败：${err instanceof Error ? err.message : String(err)}`, 1, '');
+    }
+}
+/** 解析确认回答：y/yes（大小写不敏感，容忍首尾空白）为确认。 */
+export function parseConfirmAnswer(s) {
+    const t = s.trim().toLowerCase();
+    return t === 'y' || t === 'yes';
+}
 /** 报告 (label, value) 是否已被确认过。 */
 export async function confirmCheck(label, value) {
-    const inv = await invokeEngine(['confirm', 'check', label, value]);
-    assertSuccess(inv, 'picktui confirm check');
-    const parsed = parseJSON(inv.stdout, 'picktui confirm check');
-    return parsed.confirmed;
+    return isConfirmed(label, value);
 }
-/**
- * 记录 (label, value) 为已确认（幂等）。
- * @returns 确认后的实际状态（label 为空时不落盘 → false）
- */
+/** 记录 (label, value) 为已确认（幂等）；返回确认后的实际状态。 */
 export async function confirmAdd(label, value) {
-    const inv = await invokeEngine(['confirm', 'add', label, value]);
-    assertSuccess(inv, 'picktui confirm add');
-    const parsed = parseJSON(inv.stdout, 'picktui confirm add');
-    return parsed.confirmed;
+    confirm(label, value);
+    return isConfirmed(label, value);
 }

package/dist/esm/filter.js

@@ -1,45 +1,297 @@
 /**
- * filter / resolve — 纯函数数据面（直调引擎 filter/resolve --json）。
+ * filter / resolve — 纯 TS 过滤匹配引擎（对齐 Go filter.go，零依赖）。
  *
- * 过滤与高亮区间由引擎权威计算；本模块只做「候选传入、JSON 取回」，
- * 禁止重实现匹配（详见 docs/integration/protocol.md 兼容性承诺）。
+ * 三种匹配模式（与协议一致）：
+ *   - 子串 AND（默认）：空格分关键字，全部命中才保留，大小写不敏感
+ *   - token 前缀（--sep <chars>）：按分隔符集合切 token（默认 _，可多字符如 ":_"），
+ *     每关键字匹配某 token 前缀
+ *   - 子序列模糊（--fuzzy）：关键字为子序列
+ *
+ * 高亮区间为 rune（code point）索引 [start, end)，排序合并；空查询恒 []。
  */
-import { assertSuccess, invokeEngine, parseJSON, serializeCandidates, } from './engine.js';
-/** 将 FilterOptions 转为引擎参数。 */
-function modeArgs(opts) {
-    const args = [];
-    if (opts.mode && opts.mode !== 'substring') {
-        args.push('--mode', opts.mode);
+import { toStructuredCands } from './cand.js';
+/** 默认分隔符集合（token 模式）。 */
+const DEFAULT_SEP = '_';
+/** 将查询字符串拆分为小写关键字列表（空格分词、小写化、过滤空串）。 */
+export function splitKeywords(query) {
+    const fields = query.trim().split(/\s+/).filter(Boolean);
+    return fields.map((f) => f.toLowerCase());
+}
+/** 按 rune 切分字符串为 code point 数组（与 Go []rune 对齐）。 */
+function toRunes(s) {
+    return [...s];
+}
+/** 某 rune 是否在分隔符集合中。 */
+function sepSetOf(sep) {
+    return new Set(toRunes(sep));
+}
+/** 按分隔符集合切分 runes，返回每个非空 token 的 [start, end) rune 索引区间。 */
+function splitRuneRanges(runes, seps) {
+    if (seps.size === 0) {
+        return runes.length > 0 ? [[0, runes.length]] : [];
+    }
+    const ranges = [];
+    let start = 0;
+    for (let i = 0; i < runes.length; i++) {
+        if (seps.has(runes[i])) {
+            if (i > start) {
+                ranges.push([start, i]);
+            }
+            start = i + 1;
+        }
+    }
+    if (start < runes.length) {
+        ranges.push([start, runes.length]);
+    }
+    return ranges;
+}
+/** 按分隔符集合切分字符串为 token 列表（供匹配用）。 */
+function splitTokens(s, seps) {
+    if (seps.size === 0) {
+        return [s];
+    }
+    const tokens = [];
+    let cur = '';
+    for (const r of s) {
+        if (seps.has(r)) {
+            if (cur !== '') {
+                tokens.push(cur);
+                cur = '';
+            }
+        }
+        else {
+            cur += r;
+        }
+    }
+    if (cur !== '') {
+        tokens.push(cur);
+    }
+    return tokens;
+}
+/** 子串 AND：所有关键字都需作为子串出现（大小写不敏感）。 */
+export function matchSubstringAll(s, kws) {
+    const lower = s.toLowerCase();
+    return kws.every((kw) => lower.includes(kw));
+}
+/** token 前缀：按分隔符集合切 token，每关键字须匹配某 token 的前缀。 */
+export function matchTokenPrefixAll(s, kws, sep) {
+    const seps = sepSetOf(sep === '' ? DEFAULT_SEP : sep);
+    const tokens = splitTokens(s.toLowerCase(), seps);
+    return kws.every((kw) => tokens.some((tok) => tok.startsWith(kw)));
+}
+/** 子序列模糊：所有关键字都需作为子序列出现（大小写不敏感）。 */
+export function matchFuzzyAll(s, kws) {
+    const lower = s.toLowerCase();
+    return kws.every((kw) => isSubsequence(kw, lower));
+}
+/** pat 是否为 s 的子序列（不要求连续）。 */
+export function isSubsequence(pat, s) {
+    if (pat === '') {
+        return true;
     }
-    if (opts.mode === 'token' && opts.sep) {
-        args.push('--sep', opts.sep);
+    let pi = 0;
+    for (let si = 0; si < s.length && pi < pat.length; si++) {
+        if (s[si] === pat[pi]) {
+            pi++;
+        }
     }
-    return args;
+    return pi === pat.length;
+}
+/** rune 索引：在 s 中查找 substr 的首个出现位置，未找到返回 -1。 */
+function runeIndex(s, substr) {
+    if (substr.length === 0 || substr.length > s.length) {
+        return -1;
+    }
+    for (let i = 0; i <= s.length - substr.length; i++) {
+        let match = true;
+        for (let j = 0; j < substr.length; j++) {
+            if (s[i + j] !== substr[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match) {
+            return i;
+        }
+    }
+    return -1;
+}
+/** 排序并合并重叠的 [start, end) 区间（与 Go mergeRanges 一致）。 */
+export function mergeRanges(ranges) {
+    if (ranges.length === 0) {
+        return [];
+    }
+    const sorted = [...ranges].sort((a, b) => (a[0] !== b[0] ? a[0] - b[0] : a[1] - b[1]));
+    const merged = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+        const last = merged[merged.length - 1];
+        const r = sorted[i];
+        if (r[0] <= last[1]) {
+            if (r[1] > last[1]) {
+                last[1] = r[1];
+            }
+        }
+        else {
+            merged.push(r);
+        }
+    }
+    return merged;
+}
+/**
+ * highlightRanges 返回 s 中匹配关键字的 [start, end) rune 索引区间（已排序合并）。
+ * 空查询返回 []。
+ */
+export function highlightRanges(s, query, opts = {}) {
+    const kws = splitKeywords(query);
+    if (kws.length === 0) {
+        return [];
+    }
+    const lowerRunes = toRunes(s.toLowerCase());
+    const ranges = [];
+    const mode = opts.mode ?? 'substring';
+    if (mode === 'token') {
+        const seps = sepSetOf(opts.sep === undefined || opts.sep === '' ? DEFAULT_SEP : opts.sep);
+        const tokRanges = splitRuneRanges(lowerRunes, seps);
+        for (const kw of kws) {
+            const kwRunes = toRunes(kw);
+            if (kwRunes.length === 0) {
+                continue;
+            }
+            for (const tr of tokRanges) {
+                const tok = lowerRunes.slice(tr[0], tr[1]);
+                if (hasRunePrefix(tok, kwRunes)) {
+                    ranges.push([tr[0], tr[0] + kwRunes.length]);
+                    break;
+                }
+            }
+        }
+    }
+    else if (mode === 'fuzzy') {
+        for (const kw of kws) {
+            const positions = subsequenceRunePositions(toRunes(kw), lowerRunes);
+            for (const p of positions) {
+                ranges.push([p, p + 1]);
+            }
+        }
+    }
+    else {
+        for (const kw of kws) {
+            const kwRunes = toRunes(kw);
+            if (kwRunes.length === 0) {
+                continue;
+            }
+            const idx = runeIndex(lowerRunes, kwRunes);
+            if (idx >= 0) {
+                ranges.push([idx, idx + kwRunes.length]);
+            }
+        }
+    }
+    return mergeRanges(ranges);
+}
+function hasRunePrefix(s, prefix) {
+    if (prefix.length > s.length) {
+        return false;
+    }
+    for (let i = 0; i < prefix.length; i++) {
+        if (s[i] !== prefix[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+/** 返回 pat 作为 s 子序列匹配时的各字符 rune 位置；不完整匹配返回 []。 */
+function subsequenceRunePositions(pat, s) {
+    if (pat.length === 0) {
+        return [];
+    }
+    const positions = [];
+    let pi = 0;
+    for (let si = 0; si < s.length && pi < pat.length; si++) {
+        if (s[si] === pat[pi]) {
+            positions.push(si);
+            pi++;
+        }
+    }
+    if (pi < pat.length) {
+        return [];
+    }
+    return positions;
+}
+/** 匹配模式分派：单候选是否命中全部关键字。 */
+export function matchCandidate(s, kws, opts = {}) {
+    switch (opts.mode ?? 'substring') {
+        case 'token':
+            return matchTokenPrefixAll(s, kws, opts.sep ?? '');
+        case 'fuzzy':
+            return matchFuzzyAll(s, kws);
+        default:
+            return matchSubstringAll(s, kws);
+    }
+}
+/** 归一化 FilterOptions（对齐协议 --mode/--sep 语义）。 */
+export function normalizeOpts(opts = {}) {
+    return { mode: opts.mode ?? 'substring', sep: opts.sep ?? '' };
+}
+/**
+ * filterCands — 过滤 + 高亮区间（纯同步，保留输入顺序）。
+ * 描述不参与过滤——过滤永远针对"选中什么"而非"展示什么"。空查询返回全部。
+ */
+export function filterCands(cands, query, opts = {}) {
+    const kws = splitKeywords(query);
+    if (kws.length === 0) {
+        return cands.map((c) => ({ value: c.value, desc: c.desc ?? '', ranges: [] }));
+    }
+    const norm = normalizeOpts(opts);
+    const out = [];
+    for (const c of cands) {
+        if (matchCandidate(c.value, kws, norm)) {
+            out.push({
+                value: c.value,
+                desc: c.desc ?? '',
+                ranges: highlightRanges(c.value, query, norm),
+            });
+        }
+    }
+    return out;
+}
+/**
+ * autoResolve — 把查询字符串解析为唯一候选（供 --auto 自动选中）：
+ *   1. 精确匹配（大小写敏感）直接命中；
+ *   2. 否则大小写不敏感的唯一前缀匹配；
+ * 无匹配或多个前缀匹配时返回 null。
+ */
+export function autoResolve(cands, query) {
+    if (query === '') {
+        return null;
+    }
+    for (const c of cands) {
+        if (c.value === query) {
+            return c.value;
+        }
+    }
+    const lq = query.toLowerCase();
+    let only = null;
+    for (const c of cands) {
+        if (c.value.toLowerCase().startsWith(lq)) {
+            if (only !== null && only !== c.value) {
+                return null; // 多个前缀匹配，无法唯一确定
+            }
+            only = c.value;
+        }
+    }
+    return only;
 }
 /**
  * filter — 过滤候选并返回命中项（保留输入顺序）+ 高亮区间。
- *
- * @param cands 候选（字符串或结构化 Candidate）
- * @param query 过滤关键字（空格分词，空串返回全部）
- * @param opts  匹配模式（默认 substring）
- * @returns 命中候选，`ranges` 为命中的 rune 区间（空查询恒为 []）
+ * 与协议 filter --json 等价；空查询返回全部（ranges 恒为 []）。
  */
-export async function filter(cands, query = '', opts = {}) {
-    const inv = await invokeEngine(['filter', '--json', '--query', query, ...modeArgs(opts)], { input: serializeCandidates(cands) });
-    assertSuccess(inv, 'picktui filter');
-    return parseJSON(inv.stdout, 'picktui filter');
+export function filter(cands, query = '', opts = {}) {
+    return Promise.resolve(filterCands(toStructuredCands(cands), query, opts));
 }
 /**
  * resolve — 把 query 解析为唯一候选（精确 → 唯一前缀，大小写不敏感前缀）。
- *
- * @returns 解析出的选中值；无匹配/多个前缀匹配返回 null（引擎退出码 1）
+ * @returns 解析出的选中值；无匹配/多个前缀匹配/空 query 返回 null
  */
-export async function resolve(cands, query, opts = {}) {
-    const inv = await invokeEngine(['resolve', '--json', '--query', query, ...modeArgs(opts)], { input: serializeCandidates(cands) });
-    if (inv.exitCode === 1) {
-        return null; // 协议：无唯一解 → stdout 空 + 退出码 1
-    }
-    assertSuccess(inv, 'picktui resolve');
-    const parsed = parseJSON(inv.stdout, 'picktui resolve');
-    return parsed.value;
+export function resolve(cands, query, _opts = {}) {
+    return Promise.resolve(autoResolve(toStructuredCands(cands), query));
 }

package/dist/esm/history.js

@@ -1,19 +1,108 @@
 /**
- * history — 选择记忆（文件状态，直调引擎 hist 子命令）。
+ * history — 选择记忆：记住每个选择器/歧义点上次选中的候选（history.toml）。
  *
- * 状态文件位于引擎数据目录（$PICKTUI_CONFIG_DIR → $XDG_CONFIG_HOME/picktui →
- * ~/.config/picktui），与 pick --label 的 TUI 记忆同一份。
+ * 文件格式与 Go 引擎 BurntSushi/toml 输出完全兼容（同一数据目录共用）：
+ *
+ *	# picktui history — last selection per key (auto-managed)
+ *	["git p"]
+ *	last = "pull"
+ *
+ * 曾用名 picks.toml 仍会被自动迁移到新位置（与引擎行为一致）。
+ * 文件不存在或损坏 → 空记录（记忆只是锦上添花，静默容错）。
  */
-import { assertSuccess, invokeEngine, parseJSON } from './engine.js';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { dataDir } from './config.js';
+import { parseToml, escapeTomlString, keyLiteral } from './toml.js';
+import { PicktuiError } from './types.js';
+/** 选择记忆文件名；曾用名 picks.toml 因易与 pick 命令混淆而弃用。 */
+export const HISTORY_FILE = 'history.toml';
+/** 旧版文件名，仅用于首次读取时自动迁移。 */
+export const LEGACY_HISTORY_FILE = 'picks.toml';
+/** 注释头（对齐引擎输出，便于用户辨识文件来源）。 */
+const HEADER = '# picktui history — last selection per key (auto-managed)';
+/** 返回选择记忆文件路径。 */
+export function historyPath() {
+    return join(dataDir(), HISTORY_FILE);
+}
+/** history.toml 原始内容（label → { last }），与引擎同一份。 */
+export function loadPickHistory() {
+    const doc = loadHistoryToml();
+    const out = new Map();
+    for (const label of doc.keys()) {
+        const table = doc.get(label);
+        if (!table) {
+            continue;
+        }
+        const last = table.get('last');
+        if (typeof last === 'string') {
+            out.set(label, last);
+        }
+    }
+    return out;
+}
+/** 读取/迁移 history.toml：不存在时静默返回空 Map。 */
+function loadHistoryToml() {
+    const p = historyPath();
+    if (existsSync(p)) {
+        return parseHistoryFile(readFileSync(p, 'utf8'));
+    }
+    const legacy = join(dataDir(), LEGACY_HISTORY_FILE);
+    if (existsSync(legacy)) {
+        const raw = parseHistoryFile(readFileSync(legacy, 'utf8'));
+        try {
+            writeHistoryEntries(raw);
+            rmSync(legacy, { force: true });
+        }
+        catch {
+            // 迁移写入失败不阻断读取——旧数据仍在内存中可用
+        }
+        return raw;
+    }
+    return new Map();
+}
+/** 解析 history.toml 文本；损坏时静默返回空（对齐引擎 LoadPickHistory）。 */
+function parseHistoryFile(text) {
+    const doc = parseToml(text);
+    if (doc === null) {
+        return new Map();
+    }
+    return doc;
+}
+/** 取回 label 上次选中的值；无记录返回 ""。 */
+export function lastPick(raw, label) {
+    return raw.get(label) ?? '';
+}
+/** 记录 label 的上次选中值（保留其它 label 的记忆后写回）。 */
+export function savePick(label, value) {
+    const raw = loadPickHistory();
+    raw.set(label, value);
+    writeHistoryEntries(raw);
+}
+/** 将记忆写回 history.toml（自动建目录，对齐引擎输出格式）。 */
+function writeHistoryEntries(entries) {
+    const lines = [HEADER];
+    const labels = [...entries.keys()].sort();
+    for (const label of labels) {
+        lines.push(`[${keyLiteral(label)}]`);
+        const table = entries.get(label);
+        const last = table instanceof Map ? table.get('last') : table;
+        lines.push(`last = "${escapeTomlString(last ?? '')}"`);
+    }
+    const p = historyPath();
+    try {
+        mkdirSync(dirname(p), { recursive: true });
+        writeFileSync(p, lines.join('\n') + '\n', { mode: 0o644 });
+    }
+    catch (err) {
+        throw new PicktuiError(`写入选择记忆失败：${err instanceof Error ? err.message : String(err)}`, 1, '');
+    }
+}
 /** 读取 label 上次选中的值；无记录返回 ""。 */
 export async function histGet(label) {
-    const inv = await invokeEngine(['hist', 'get', label]);
-    assertSuccess(inv, 'picktui hist get');
-    const parsed = parseJSON(inv.stdout, 'picktui hist get');
-    return parsed.last ?? '';
+    return lastPick(loadPickHistory(), label);
 }
-/** 记录 label 的上次选中值（成功无输出；失败抛 PicktuiError）。 */
+/** 记录 label 的上次选中值（失败抛 PicktuiError，含退出码 1）。 */
 export async function histSet(label, value) {
-    const inv = await invokeEngine(['hist', 'set', label, value]);
-    assertSuccess(inv, 'picktui hist set');
+    savePick(label, value);
 }

package/dist/esm/index.js

@@ -4,8 +4,9 @@
  *   import { pick } from '@havocrao/picktui/tui'
  *   import { histGet } from '@havocrao/picktui/history'
  */
+/** 本 TS 实现的语义版本（对齐 npm 包版本号）。 */
+export const VERSION = '0.1.0';
 export * from './types.js';
-export * from './engine.js';
 export * from './filter.js';
 export * from './tui.js';
 export * from './history.js';