rigjs 3.0.33 → 4.0.3

package/lib/wiki/qmd.ts

@@ -0,0 +1,205 @@
+// qmd integration — in-process Node SDK (`@tobilu/qmd`).
+//
+// rig wiki is vector-only: indexing always embeds, queries are pure
+// `searchVector` followed by a Qwen3-Reranker pass. No BM25, no query
+// expansion, no language-specific tokenizer headaches.
+//
+// Two models, both mirrored on the personal CDN for zero-config global
+// acceleration (China + worldwide via Aliyun PoPs):
+//   - Embed: Qwen3-Embedding-0.6B   (~610MB, sets QMD_EMBED_MODEL)
+//   - Rerank: Qwen3-Reranker-0.6B   (~610MB, sets QMD_RERANK_MODEL)
+//
+// Per-wiki SQLite DB lives at `~/.rig/cache/qmd/<wiki>.sqlite`. Model GGUFs
+// cache in `~/.cache/qmd/models/` (hardcoded inside qmd).
+//
+// Concurrency note: qmd's `setConfigSource` is module-global; serialize
+// store lifetimes by opening + closing inside each call.
+
+import fs from 'fs';
+import path from 'path';
+import { paths } from './paths';
+
+// CDN-backed defaults. node-llama-cpp's resolveModelFile accepts https://.
+// qmd's `isQwen3EmbeddingModel` matches "Qwen.*Embed" in the URI, so the
+// Qwen3 query-instruction template (Instruct:/Query:) is auto-applied.
+const DEFAULT_EMBED_MODEL_URL = 'https://assets.terncloud.com/rig/models/Qwen3-Embedding-0.6B-Q8_0.gguf';
+const DEFAULT_RERANK_MODEL_URL = 'https://assets.terncloud.com/rig/models/qwen3-reranker-0.6b-q8_0.gguf';
+
+// Apply rig defaults unless the user pinned different ones. Runs at module
+// load so every qmd call inherits without the caller worrying.
+if (!process.env.QMD_EMBED_MODEL) process.env.QMD_EMBED_MODEL = DEFAULT_EMBED_MODEL_URL;
+if (!process.env.QMD_RERANK_MODEL) process.env.QMD_RERANK_MODEL = DEFAULT_RERANK_MODEL_URL;
+
+export interface QmdInfo {
+  installed: true;
+  version: string;
+  bundled: true;
+  embedModel: string;
+  rerankModel: string;
+}
+
+let infoCache: QmdInfo | null = null;
+
+export function detectQmd(): QmdInfo {
+  if (infoCache) return infoCache;
+  infoCache = {
+    installed: true,
+    version: qmdVersion(),
+    bundled: true,
+    embedModel: process.env.QMD_EMBED_MODEL || DEFAULT_EMBED_MODEL_URL,
+    rerankModel: process.env.QMD_RERANK_MODEL || DEFAULT_RERANK_MODEL_URL,
+  };
+  return infoCache;
+}
+
+// qmd's `exports` field blocks `require.resolve('@tobilu/qmd')`; walk up
+// from __dirname looking for node_modules/@tobilu/qmd/package.json instead.
+function qmdVersion(): string {
+  try {
+    let dir = __dirname;
+    for (let i = 0; i < 8; i++) {
+      const p = path.join(dir, 'node_modules', '@tobilu', 'qmd', 'package.json');
+      if (fs.existsSync(p)) {
+        const pkg = JSON.parse(fs.readFileSync(p, 'utf8'));
+        if (pkg.name === '@tobilu/qmd' && typeof pkg.version === 'string') return pkg.version;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch { /* fall through */ }
+  return 'unknown';
+}
+
+function dbPathFor(wikiName: string): string {
+  const dir = path.join(paths.cache, 'qmd');
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, `${wikiName}.sqlite`);
+}
+
+async function loadQmd(): Promise<{ createStore: any }> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const m: any = await import('@tobilu/qmd');
+  return { createStore: m.createStore };
+}
+
+/**
+ * Embed a wiki dir. Incremental by default; pass `{ force: true }` to
+ * re-embed everything (e.g. after switching the embed model).
+ */
+export async function qmdEmbed(
+  wikiName: string,
+  dir: string,
+  opts: { force?: boolean } = {}
+): Promise<{ ok: boolean; stderr: string }> {
+  try {
+    const { createStore } = await loadQmd();
+    const store = await createStore({
+      dbPath: dbPathFor(wikiName),
+      config: {
+        collections: { [wikiName]: { path: dir, pattern: '**/*.md' } },
+      },
+    });
+    try {
+      await store.update({});
+      await store.embed({ chunkStrategy: 'auto', force: !!opts.force });
+    } finally {
+      await store.close();
+    }
+    return { ok: true, stderr: '' };
+  } catch (e) {
+    return { ok: false, stderr: errMsg(e) };
+  }
+}
+
+export interface QmdHit {
+  file: string;
+  displayPath?: string;
+  title?: string;
+  body?: string;
+  score: number;
+  rerankScore?: number;
+}
+
+/**
+ * Pure vector search + Qwen3 reranker.
+ *
+ * Pipeline:
+ *   1. searchVector(top 40, dedup'd by docid via qmd internals)
+ *   2. Store.rerank() against the candidate set's chunk bodies
+ *   3. Sort by rerank score, return top-k
+ *
+ * Set `{ rerank: false }` to skip step 2 (faster, no reranker model load).
+ */
+export async function qmdQuery(
+  q: string,
+  wikiName: string,
+  opts: { limit?: number; candidateLimit?: number; rerank?: boolean } = {}
+): Promise<QmdHit[] | null> {
+  const limit = opts.limit ?? 10;
+  const candidateLimit = Math.max(limit, opts.candidateLimit ?? 40);
+  const doRerank = opts.rerank !== false; // default ON
+
+  try {
+    const { createStore } = await loadQmd();
+    const store = await createStore({ dbPath: dbPathFor(wikiName) });
+    try {
+      const raw = await store.searchVector(q, { limit: candidateLimit, collection: wikiName });
+      const candidates: QmdHit[] = Array.isArray(raw) ? raw.map(normalizeHit) : [];
+      if (!doRerank || candidates.length === 0) return candidates.slice(0, limit);
+
+      const docs = candidates
+        .filter(c => c.file && (c.body || ''))
+        .map(c => ({ file: c.file, text: c.body || '' }));
+      if (docs.length === 0) return candidates.slice(0, limit);
+
+      // qmd 2.5.x exposes `rerank` only on store.internal (not on the public
+      // QMDStore). store.search(opts) does include reranking but also runs
+      // BM25 + query expansion, which we want to avoid.
+      const reranker = store.internal && store.internal.rerank;
+      if (typeof reranker !== 'function') {
+        // No standalone rerank available — return vector hits as-is.
+        return candidates.slice(0, limit);
+      }
+      const ranked: { file: string; score: number }[] = await reranker(q, docs);
+      const scoreByFile = new Map(ranked.map(r => [r.file, r.score]));
+      const merged = candidates.map(c => ({
+        ...c,
+        rerankScore: scoreByFile.get(c.file) ?? 0,
+      }));
+      merged.sort((a, b) => (b.rerankScore ?? 0) - (a.rerankScore ?? 0));
+      return merged.slice(0, limit);
+    } finally {
+      await store.close();
+    }
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(`qmd query error: ${errMsg(e)}`);
+    return null;
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function normalizeHit(h: any): QmdHit {
+  return {
+    file: h.file ?? h.displayPath ?? '',
+    displayPath: h.displayPath,
+    title: h.title,
+    body: h.bestChunk ?? h.body ?? '',
+    score: typeof h.score === 'number' ? h.score : 0,
+  };
+}
+
+/** Wipe the per-wiki SQLite store on disk. Caller should then qmdEmbed. */
+export function qmdResetStore(wikiName: string): void {
+  const p = dbPathFor(wikiName);
+  for (const suffix of ['', '-wal', '-shm']) {
+    const f = p + suffix;
+    if (fs.existsSync(f)) fs.rmSync(f, { force: true });
+  }
+}
+
+function errMsg(e: unknown): string {
+  if (e && typeof e === 'object' && 'message' in e) return String((e as { message: unknown }).message);
+  return String(e);
+}

package/lib/wiki/query.ts

@@ -0,0 +1,144 @@
+// `rig wiki query` — vector retrieval over a registered wiki.
+//
+// Pipeline: Qwen3-Embedding-0.6B (sqlite-vec) → Qwen3-Reranker-0.6B → top-k.
+// No BM25, no query expansion. Cross-lingual (Chinese ↔ English) works
+// because both Qwen3 models are multilingual.
+//
+// Default output is human-readable; --json emits the raw payload. --synth
+// invokes the Claude adapter to write a short answer paragraph with
+// [[wikilink]] citations.
+
+import path from 'path';
+import print from '../print';
+import { loadWikiConfig, resolveWiki, loadRigConfig, WikiEntry } from './config';
+import { qmdQuery, QmdHit } from './qmd';
+import { adapters } from './agent/registry';
+
+interface QueryOpts {
+  wiki?: string;
+  json?: boolean;
+  limit?: number;
+  synth?: boolean;
+  // Commander resolves `--no-rerank` → `opts.rerank: false`. Default true.
+  rerank?: boolean;
+}
+
+export default async function wikiQuery(q: string, opts: QueryOpts): Promise<void> {
+  if (!q || !q.trim()) {
+    print.error('empty query.');
+    process.exit(1);
+  }
+  const cfg = loadWikiConfig();
+  const target = resolveWiki(cfg, opts.wiki);
+  if (!target) {
+    print.error('no wiki resolved. Pass --wiki <name> or run from inside a registered project.');
+    process.exit(1);
+  }
+
+  const limit = Math.max(1, Math.min(50, opts.limit || 10));
+  const hits = await qmdQuery(q, target.name, { limit, rerank: opts.rerank !== false });
+  if (hits === null) {
+    print.error('qmd query failed. Run `rig wiki index` first to (re)build the vector store.');
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    // eslint-disable-next-line no-console
+    console.log(JSON.stringify({ ok: true, code: 0, data: { query: q, hits } }, null, 2));
+    return;
+  }
+
+  printHits(target, q, hits);
+  if (opts.synth) await synthesize(target, q, hits);
+}
+
+function printHits(wiki: WikiEntry, q: string, hits: QmdHit[]): void {
+  print.info(`query: ${q}`);
+  if (hits.length === 0) {
+    print.warn('no hits.');
+    return;
+  }
+  // eslint-disable-next-line no-console
+  console.log('');
+  hits.forEach((h, i) => {
+    const filePath = h.file || h.displayPath || '<unknown>';
+    const wlink = toWikilink(wiki, filePath);
+    const score = typeof h.rerankScore === 'number' ? h.rerankScore : h.score;
+    const scoreStr = typeof score === 'number' ? score.toFixed(4) : '—';
+    const head = wlink ? `[[${wlink}]]` : filePath;
+    // eslint-disable-next-line no-console
+    console.log(`${String(i + 1).padStart(2)}. ${head}  (score=${scoreStr})`);
+    const snippet = (h.body || '').trim().replace(/\s+/g, ' ').slice(0, 220);
+    if (snippet) {
+      // eslint-disable-next-line no-console
+      console.log(`    ${snippet}${snippet.length === 220 ? '…' : ''}`);
+    }
+  });
+  // eslint-disable-next-line no-console
+  console.log('');
+}
+
+// "/abs/.../wiki/sources/foo.md" → "foo". Outside wiki/<sub>/ → null so the
+// caller falls back to printing the literal path.
+function toWikilink(wiki: WikiEntry, filePath: string): string | null {
+  try {
+    const abs = path.isAbsolute(filePath) ? filePath : path.resolve(wiki.path, filePath);
+    const wikiRoot = path.join(wiki.path, 'wiki') + path.sep;
+    if (!abs.startsWith(wikiRoot)) return null;
+    return path.basename(abs, path.extname(abs));
+  } catch { return null; }
+}
+
+async function synthesize(wiki: WikiEntry, q: string, hits: QmdHit[]): Promise<void> {
+  const rig = loadRigConfig();
+  const which = rig.wiki?.defaultAgent || 'claude';
+  const adapter = adapters.find(a => a.name === which);
+  if (!adapter) {
+    print.warn(`no agent adapter named ${which}; skipping synthesis.`);
+    return;
+  }
+  const detect = await adapter.detect();
+  if (!detect.installed) {
+    print.warn(`${which} not installed on PATH; skipping synthesis.`);
+    return;
+  }
+
+  const ctx = hits.slice(0, 8).map((h, i) => {
+    const filePath = h.file || h.displayPath || '<unknown>';
+    const wlink = toWikilink(wiki, filePath);
+    const cite = wlink ? `[[${wlink}]]` : filePath;
+    const body = (h.body || '').trim().slice(0, 1200);
+    return `## hit ${i + 1} ${cite}\n${body}`;
+  }).join('\n\n');
+
+  const prompt = [
+    `You are answering a question about a personal wiki.`,
+    `Question: ${q}`,
+    ``,
+    `Top retrieval results follow. Synthesize a concise answer (≤ 6 sentences)`,
+    `that cites the hits using [[wikilink]] format inline. If the hits don't`,
+    `support an answer, say so. Do NOT write to any files. Output text only.`,
+    ``,
+    ctx,
+  ].join('\n');
+
+  print.start(`${which} synthesize`);
+  const res = await adapter.run({
+    prompt,
+    cwd: wiki.path,
+    allowWrite: false,
+    tools: [],
+    timeoutMs: 5 * 60 * 1000,
+  });
+  if (!res.ok) {
+    print.error(`${which} failed (code ${res.exitCode})${res.stderr ? `: ${res.stderr.trim().slice(0, 300)}` : ''}`);
+    return;
+  }
+  print.succeed(`${which} answer:`);
+  // eslint-disable-next-line no-console
+  console.log('');
+  // eslint-disable-next-line no-console
+  console.log(res.stdout.trim());
+  // eslint-disable-next-line no-console
+  console.log('');
+}

package/lib/wiki/rebuild.ts

@@ -0,0 +1,56 @@
+// `rig wiki rebuild` — refresh local-only caches for a wiki.
+//
+// Use cases:
+//   1. New device: source markdown is checked out, but ~/.rig/state.db and
+//      ~/.rig/cache/qmd/<wiki>.sqlite are empty. Rebuild populates both.
+//   2. Switched embedding model: old vectors are now meaningless. Rebuild
+//      re-embeds against the current QMD_EMBED_MODEL.
+//   3. Local cache corruption: nuke and start over.
+//
+// What it does:
+//   - clear `source_sha` rows for the wiki in ~/.rig/state.db
+//   - drop the per-wiki qmd sqlite store
+//   - full re-embed (Qwen3-Embedding by default)
+
+import print from '../print';
+import { loadWikiConfig, resolveWiki, WikiEntry } from './config';
+import { getDb, recordLastRun } from './db';
+import { qmdEmbed, qmdResetStore } from './qmd';
+
+interface RebuildOpts { wiki?: string; all?: boolean; skipEmbed?: boolean; }
+
+export default async function wikiRebuild(opts: RebuildOpts): Promise<void> {
+  const cfg = loadWikiConfig();
+  const targets: WikiEntry[] = opts.all
+    ? cfg.wikis
+    : [resolveWiki(cfg, opts.wiki)].filter(Boolean) as WikiEntry[];
+  if (targets.length === 0) {
+    print.error('no wiki resolved. Pass --wiki <name>, --all, or run from inside a registered project.');
+    process.exit(1);
+  }
+
+  const db = getDb();
+  for (const t of targets) {
+    print.start(`rebuild: ${t.name}`);
+    const del = db.prepare('DELETE FROM source_sha WHERE wiki = ?').run(t.name);
+    print.info(`  cleared ${del.changes} source_sha rows for ${t.name}`);
+
+    qmdResetStore(t.name);
+
+    if (!opts.skipEmbed) {
+      const res = await qmdEmbed(t.name, t.path, { force: true });
+      if (res.ok) print.info(`  qmd embed: ${t.name} done`);
+      else {
+        print.error(`  qmd embed: ${t.name} failed: ${res.stderr.trim()}`);
+        recordLastRun(t.name, 'rebuild', 1);
+        process.exitCode = 1;
+        continue;
+      }
+    }
+
+    recordLastRun(t.name, 'rebuild', 0);
+    print.succeed(`rebuilt: ${t.name}`);
+  }
+
+  print.info('next: run `rig wiki scan` to baseline the new sha index.');
+}

package/lib/wiki/register.ts

@@ -0,0 +1,131 @@
+import fs from 'fs';
+import path from 'path';
+import JSON5 from 'json5';
+import print from '../print';
+import { loadWikiConfig, saveWikiConfig, WikiEntry } from './config';
+
+interface RegisterOpts {
+  as?: string;
+  force?: boolean;
+}
+
+export default function wikiRegister(givenPath: string | undefined, opts: RegisterOpts): void {
+  const wikiPath = path.resolve(givenPath || detectWikiPath(process.cwd()) || process.cwd());
+  if (!fs.existsSync(wikiPath)) {
+    print.error(`path does not exist: ${wikiPath}`);
+    process.exit(1);
+  }
+  const project = detectProjectRoot(wikiPath);
+  const name = (opts.as || detectName(project, wikiPath)).trim();
+  if (!name) {
+    print.error('failed to derive a wiki name; pass --name <n>');
+    process.exit(1);
+  }
+
+  const cfg = loadWikiConfig();
+  const existing = cfg.wikis.findIndex(w => w.name === name);
+  if (existing >= 0 && !opts.force) {
+    print.error(`wiki "${name}" already registered at ${cfg.wikis[existing].path}; pass --force to overwrite`);
+    process.exit(1);
+  }
+
+  // Read project-local overrides (include / exclude / ingestRules / schedule)
+  // from package.rig.json5 if present. The user is the authoritative voice for
+  // what gets scanned. Falls back to safe defaults only when fields are absent.
+  const projectWiki = project ? readProjectWikiBlock(project) : null;
+  const wikiBasename = path.basename(wikiPath);
+  const entry: WikiEntry = {
+    name,
+    path: wikiPath,
+    project: project || undefined,
+    include: projectWiki?.include ?? ['**/*.md'],
+    exclude: projectWiki?.exclude ?? [`${wikiBasename}/**`, 'node_modules/**', '.git/**'],
+    schedule: projectWiki?.schedule ?? { scan: '0 */6 * * *', lint: '0 3 * * *' },
+    ingestRules: projectWiki?.ingestRules ?? [{ match: 'raw/**/*.md', mode: 'auto-on-new' }],
+  };
+
+  if (existing >= 0) cfg.wikis[existing] = entry;
+  else cfg.wikis.push(entry);
+  saveWikiConfig(cfg);
+
+  // bidirectional: write back to project's package.rig.json5 — preserve any
+  // existing include/exclude/ingestRules/schedule fields the user authored.
+  if (project) writeProjectWikiBlock(project, name, wikiPath, projectWiki);
+
+  print.succeed(`registered wiki "${name}" -> ${wikiPath}`);
+}
+
+interface ProjectWikiBlock {
+  name?: string;
+  path?: string;
+  include?: string[];
+  exclude?: string[];
+  schedule?: { scan?: string; lint?: string; ingest?: string | null };
+  ingestRules?: { match: string; mode: 'auto-on-new' | 'propose-only' }[];
+}
+
+function readProjectWikiBlock(project: string): ProjectWikiBlock | null {
+  const file = path.join(project, 'package.rig.json5');
+  if (!fs.existsSync(file)) return null;
+  try {
+    const cfg = JSON5.parse(fs.readFileSync(file, 'utf8'));
+    const wiki = cfg && typeof cfg === 'object' && cfg.wiki;
+    return wiki && typeof wiki === 'object' ? wiki as ProjectWikiBlock : null;
+  } catch { return null; }
+}
+
+function detectWikiPath(start: string): string | undefined {
+  const candidates = ['harness/llm-wiki', 'wiki'];
+  let dir = start;
+  while (true) {
+    for (const c of candidates) {
+      const cand = path.join(dir, c);
+      if (fs.existsSync(path.join(cand, 'purpose.md'))) return cand;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function detectProjectRoot(wikiPath: string): string | undefined {
+  let dir = wikiPath;
+  while (true) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function detectName(project: string | undefined, wikiPath: string): string {
+  if (project) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(project, 'package.json'), 'utf8'));
+      if (pkg && typeof pkg.name === 'string') return pkg.name.replace(/^@.*\//, '');
+    } catch { /* fall through */ }
+  }
+  return path.basename(path.dirname(wikiPath));
+}
+
+function writeProjectWikiBlock(
+  project: string,
+  name: string,
+  wikiPath: string,
+  existingWiki: ProjectWikiBlock | null,
+): void {
+  const file = path.join(project, 'package.rig.json5');
+  let cfg: Record<string, unknown> = {};
+  if (fs.existsSync(file)) {
+    try { cfg = JSON5.parse(fs.readFileSync(file, 'utf8')); } catch { cfg = {}; }
+  }
+  // Always update name + path (those are derived from invocation). Preserve
+  // every other field the user authored (include / exclude / schedule /
+  // ingestRules / anything else they put in there).
+  cfg.wiki = {
+    ...(existingWiki || {}),
+    name,
+    path: path.relative(project, wikiPath),
+  };
+  fs.writeFileSync(file, JSON5.stringify(cfg, null, 2) + '\n', 'utf8');
+}

package/lib/wiki/uninstallSkill.ts

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+import print from '../print';
+import { paths } from './paths';
+
+export default function wikiUninstallSkill(): void {
+  const targetDir = path.join(paths.claudeSkillsDir, 'rig-wiki');
+  const target = path.join(targetDir, 'SKILL.md');
+
+  let removed = false;
+  if (fs.existsSync(target) || isBrokenSymlink(target)) {
+    fs.rmSync(target, { force: true });
+    print.succeed(`removed ${target}`);
+    removed = true;
+  }
+
+  // Clean the rig-wiki/ dir if we left it empty.
+  if (fs.existsSync(targetDir)) {
+    try {
+      if (fs.readdirSync(targetDir).length === 0) {
+        fs.rmdirSync(targetDir);
+        print.info(`removed empty dir ${targetDir}`);
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  if (!removed) print.info(`nothing to remove at ${target}`);
+}
+
+function isBrokenSymlink(p: string): boolean {
+  try {
+    fs.statSync(p);
+    return false;
+  } catch {
+    try { return Boolean(fs.readlinkSync(p)); } catch { return false; }
+  }
+}

package/lib/wiki/unregister.ts

@@ -0,0 +1,16 @@
+import path from 'path';
+import print from '../print';
+import { loadWikiConfig, saveWikiConfig } from './config';
+
+export default function wikiUnregister(nameOrPath: string): void {
+  const cfg = loadWikiConfig();
+  const target = path.resolve(nameOrPath);
+  const before = cfg.wikis.length;
+  cfg.wikis = cfg.wikis.filter(w => w.name !== nameOrPath && w.path !== target);
+  if (cfg.wikis.length === before) {
+    print.error(`no registered wiki matches "${nameOrPath}"`);
+    process.exit(1);
+  }
+  saveWikiConfig(cfg);
+  print.succeed(`unregistered "${nameOrPath}" (disk contents untouched)`);
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "rigjs",
-  "version": "3.0.33",
+  "version": "4.0.3",
+  "versionCode": 26052410,
   "description": "A multi-repos dev tool based on yarn and git.Rigjs is intended to be the simplest way to develop,share and deliver codes between different developers or different projects.",
   "keywords": [
     "modular",
@@ -13,15 +14,37 @@
     "workspaces"
   ],
   "main": "index.js",
-  "repository":{
+  "repository": {
     "type": "git",
-    "url":  "https://github.com/FlashHand/rig"
+    "url": "https://github.com/FlashHand/rig"
   },
   "author": "ralwayne",
   "license": "MIT",
   "bin": {
     "rig": "bin/rig.js"
   },
+  "engines": {
+    "node": ">=22 <27"
+  },
+  "os": [
+    "darwin"
+  ],
+  "files": [
+    "bin",
+    "built",
+    "lib",
+    "doc",
+    "scripts",
+    ".claude/skills/rig-wiki",
+    ".claude-plugin",
+    "RIG_WIKI_SKILL.md",
+    "RIG_CREW_SKILL.md",
+    "skills.md",
+    "index.js",
+    "README.md",
+    "README_CN.md",
+    "LICENSE"
+  ],
   "scripts": {
     "test": "jest",
     "test:init": "yarn build && cd demo && ts-node ../built/index.js init",
@@ -31,11 +54,16 @@
     "c": "cd demo && node ../lib/rig/index.js check",
     "envmake": "cd demo && node ../lib/rig/index.js --env prod_view_zhs",
     "t": "node lib/rig/index.js tag",
-    "deliver": "npm publish --registry=https://registry.npmjs.org",
-    "deliver:alpha": "rig tag & yarn build & npm publish --registry=https://registry.npmjs.org --tag alpha",
-    "build": "esbuild lib/rig/index.ts --platform=node --bundle --sourcemap=inline --minify --outfile=built/index.js --external:shelljs"
+    "deliver": "node scripts/publish.mjs",
+    "deliver:alpha": "rig tag && yarn build && node scripts/publish.mjs --tag alpha",
+    "build": "esbuild lib/rig/index.ts --platform=node --bundle --sourcemap=inline --minify --outfile=built/index.js --external:shelljs --external:better-sqlite3 --external:bindings --external:proxy-agent --external:@tobilu/qmd",
+    "version:code": "node scripts/version-code.mjs",
+    "version:code:peek": "node scripts/version-code.mjs --peek",
+    "prepublishOnly": "node scripts/version-code.mjs && node scripts/sync-skill.mjs && yarn build",
+    "postinstall": "node scripts/postinstall.mjs"
   },
   "dependencies": {
+    "@tobilu/qmd": "~2.5.2",
     "@types/ali-oss": "^6.16.3",
     "@types/json5": "^2.2.0",
     "@types/qs": "^6.9.7",
@@ -44,6 +72,7 @@
     "@types/uuid": "^8.3.4",
     "ali-oss": "^6.17.1",
     "axios": "^0.26.1",
+    "better-sqlite3": "12.10.0",
     "chalk": "^4.1.0",
     "commander": "6.1.0",
     "compare-versions": "^4.1.3",
@@ -59,6 +88,7 @@
   "devDependencies": {
     "@types/jest": "^28.1.1",
     "@types/node": "^17.0.21",
+    "esbuild": "0.28.0",
     "jest": "^27.5.1",
     "ts-jest": "^28.0.5",
     "ts-node": "^10.8.1",