ko-qmd 2.8.3-ko.10

package/dist/trust.d.ts

@@ -0,0 +1,152 @@
+/**
+ * trust.ts — approval gate for project-local `.qmd` config.
+ *
+ * A project-local `.qmd/index.yml` arrives with a `git clone`, and
+ * `findLocalConfigPath` adopts it automatically for any command run inside the
+ * tree. Three fields in that file can reach outside the project:
+ *
+ * - `update:` — a shell command run by `qmd update` (#886)
+ * - `collections.*.path` — any directory the process can read (#889)
+ * - `models.embed` / `models.rerank` / `models.generate` — any `hf:` repo or
+ *   local GGUF path (#889)
+ *
+ * Global `~/.config/qmd` is never gated. In-project collection paths and the
+ * built-in default model URIs are also allowed without approval: those are
+ * what a local config is for. Approvals are per config file and per gated
+ * set, recorded in `<config dir>/trusted.json`. Editing a hook, pointing a
+ * collection outside the project, or changing a custom model URI changes the
+ * digest and re-arms the gate.
+ */
+/** A collection's pre-update hook, as it will be executed. */
+export type UpdateHook = {
+    collection: string;
+    command: string;
+};
+export type CollectionPath = {
+    collection: string;
+    path: string;
+};
+export type ModelSlot = "embed" | "rerank" | "generate";
+export type ModelsSnapshot = {
+    embed?: string;
+    rerank?: string;
+    generate?: string;
+};
+export type SensitiveSnapshot = {
+    hooks: UpdateHook[];
+    paths: CollectionPath[];
+    models: ModelsSnapshot;
+};
+export type GatedItems = {
+    hooks: UpdateHook[];
+    paths: CollectionPath[];
+    models: Array<{
+        slot: ModelSlot;
+        uri: string;
+    }>;
+};
+export type BuiltinModels = Required<ModelsSnapshot>;
+export type TrustRecord = {
+    /** Digest of the gated set that was approved. */
+    hooks: string;
+    /** ISO timestamp of the approval. */
+    trustedAt: string;
+};
+export type TrustStore = Record<string, TrustRecord>;
+/** Path of the trust database. Lives beside the global config. */
+export declare function getTrustFilePath(): string;
+/**
+ * Whether a config path is project-local — i.e. discovered by walking up from
+ * the working directory rather than written by the user in their config dir.
+ *
+ * `findLocalConfigPath` and `qmd init` both use `.qmd/index.y{a,}ml`, and the
+ * global config lives in a directory named `qmd`, so the parent directory name
+ * separates the two cases without extra bookkeeping.
+ */
+export declare function isLocalConfigPath(configPath: string): boolean;
+/** Directory that contains the `.qmd` folder for a project-local config. */
+export declare function projectRootFromConfig(configPath: string): string;
+/** Expand a leading `~` to the user home directory. */
+export declare function expandUserPath(raw: string): string;
+/**
+ * Resolve a collection `path` from a project-local config: `~` expansion,
+ * then relative paths against the project root (the directory that contains
+ * `.qmd`), not against the process cwd.
+ */
+export declare function resolveConfigCollectionPath(rawPath: string, configPath: string): string;
+/**
+ * True if `rawPath` from a project-local config stays inside that project
+ * (the directory containing `.qmd`), after `~` expansion, relative
+ * resolution, and symlink realpath.
+ */
+export declare function isCollectionPathInsideProject(configPath: string, rawPath: string): boolean;
+export declare function gatedModels(models: ModelsSnapshot, builtins: BuiltinModels): Array<{
+    slot: ModelSlot;
+    uri: string;
+}>;
+export declare function gatedItems(configPath: string, snapshot: SensitiveSnapshot, builtins: BuiltinModels): GatedItems;
+export declare function hasGatedItems(gated: GatedItems): boolean;
+/**
+ * Stable digest over a hook set. Order-independent so that reordering
+ * collections in the YAML does not invalidate an approval, while any change to
+ * a command — or a new collection gaining one — does.
+ */
+export declare function hookDigest(hooks: UpdateHook[]): string;
+/**
+ * Digest of the gated surface of a project-local config: hooks, resolved
+ * collection paths, and non-default model URIs. Missing model keys and the
+ * built-in default URIs are equivalent so that `qmd init` filling defaults
+ * into the YAML does not invalidate an approval.
+ */
+export declare function sensitiveDigest(snapshot: SensitiveSnapshot, configPath: string, builtins: BuiltinModels): string;
+export declare function loadTrustStore(): TrustStore;
+export declare function isTrusted(configPath: string, digest: string): boolean;
+export declare function recordTrust(configPath: string, digest: string): void;
+/** Drop the record for a config path. Returns false if there was none. */
+export declare function revokeTrust(configPath: string): boolean;
+export declare function listTrusted(): Array<{
+    path: string;
+} & TrustRecord>;
+export type HookGateDecision = {
+    action: "run";
+    digest: string;
+} | {
+    action: "prompt";
+    digest: string;
+} | {
+    action: "skip";
+    digest: string;
+};
+export type LocalConfigGateDecision = HookGateDecision;
+/** True when the process has opted in to trusting project-local config unattended. */
+export declare function isLocalConfigTrustOptedIn(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Decide what to do with a config's `update:` hooks.
+ *
+ * Non-interactive callers — agents, CI, the MCP server — get `skip` rather than
+ * a hard failure: indexing is what they asked for, and failing the whole
+ * command would only push people toward a blanket opt-out.
+ */
+export declare function decideHookGate(options: {
+    configPath: string;
+    hooks: UpdateHook[];
+    isInteractive: boolean;
+    env?: NodeJS.ProcessEnv;
+    trustedCheck?: (configPath: string, digest: string) => boolean;
+}): HookGateDecision;
+/**
+ * Decide whether a project-local config may use its gated fields (hooks,
+ * out-of-project collection paths, non-default model URIs).
+ *
+ * In-project paths and built-in default models do not need a decision.
+ * Non-interactive callers get `skip`: in-project indexing still proceeds,
+ * hooks/outside paths/custom models do not.
+ */
+export declare function decideLocalConfigGate(options: {
+    configPath: string;
+    snapshot: SensitiveSnapshot;
+    builtins: BuiltinModels;
+    isInteractive: boolean;
+    env?: NodeJS.ProcessEnv;
+    trustedCheck?: (configPath: string, digest: string) => boolean;
+}): LocalConfigGateDecision;

package/dist/trust.js

@@ -0,0 +1,2 @@
+var D=Object.defineProperty;var n=(t,e)=>D(t,"name",{value:e,configurable:!0});import{createHash as p}from"crypto";import{existsSync as m,mkdirSync as I,readFileSync as P,realpathSync as b,writeFileSync as A}from"fs";import{basename as L,dirname as c,isAbsolute as g,join as x,relative as F,resolve as u}from"path";import{getConfigDir as U}from"./collections.js";import{qmdHomedir as S}from"./paths.js";function k(){return x(U(),"trusted.json")}n(k,"getTrustFilePath");function T(t){return!t||t==="<inline>"?!1:L(c(u(t)))===".qmd"}n(T,"isLocalConfigPath");function d(t){return c(c(u(t)))}n(d,"projectRootFromConfig");function j(t){return t==="~"?S():t.startsWith("~/")||t.startsWith("~\\")?x(S(),t.slice(2)):t}n(j,"expandUserPath");function y(t,e){const r=j(String(t??"").trim());return r?g(r)?u(r):u(d(e),r):d(e)}n(y,"resolveConfigCollectionPath");function v(t){try{return b(t)}catch{return u(t)}}n(v,"realOrResolve");function N(t,e){const r=v(d(t)),o=v(y(e,t)),i=F(r,o);return i===""?!0:g(i)?!1:!i.split(/[/\\]/).includes("..")}n(N,"isCollectionPathInsideProject");function R(t,e){const r=[];for(const o of["embed","rerank","generate"]){const i=t[o];i&&i!==e[o]&&r.push({slot:o,uri:i})}return r}n(R,"gatedModels");function O(t,e,r){return{hooks:e.hooks,paths:e.paths.filter(o=>!N(t,o.path)),models:R(e.models,r)}}n(O,"gatedItems");function G(t){return t.hooks.length>0||t.paths.length>0||t.models.length>0}n(G,"hasGatedItems");function a(t,e){const r=t[0]??"",o=e[0]??"";return r<o?-1:r>o?1:0}n(a,"byFirst");function H(t){const e=JSON.stringify(t.map(r=>[r.collection,r.command]).sort(a));return p("sha256").update(e).digest("hex")}n(H,"hookDigest");function M(t,e,r){const o=O(e,t,r),i=JSON.stringify({hooks:o.hooks.map(s=>[s.collection,s.command]).sort(a),paths:o.paths.map(s=>[s.collection,y(s.path,e)]).sort(a),models:o.models.map(s=>[s.slot,s.uri]).sort(a)});return p("sha256").update(i).digest("hex")}n(M,"sensitiveDigest");function f(){const t=k();if(!m(t))return{};try{const e=JSON.parse(P(t,"utf-8"));return!e||typeof e!="object"||Array.isArray(e)?{}:e}catch{return{}}}n(f,"loadTrustStore");function C(t){const e=k(),r=c(e);m(r)||I(r,{recursive:!0}),A(e,`${JSON.stringify(t,null,2)}
+`,"utf-8")}n(C,"saveTrustStore");function h(t){return u(t)}n(h,"trustKey");function _(t,e){return f()[h(t)]?.hooks===e}n(_,"isTrusted");function z(t,e){const r=f();r[h(t)]={hooks:e,trustedAt:new Date().toISOString()},C(r)}n(z,"recordTrust");function B(t){const e=f(),r=h(t);return r in e?(delete e[r],C(e),!0):!1}n(B,"revokeTrust");function V(){return Object.entries(f()).map(([t,e])=>({path:t,...e}))}n(V,"listTrusted");function l(t){return t?!["0","false","off","no","none"].includes(t.trim().toLowerCase()):!1}n(l,"isTruthyEnv");function J(t=process.env){return l(t.QMD_TRUST_LOCAL_CONFIG)||l(t.QMD_TRUST_UPDATE_HOOKS)}n(J,"isLocalConfigTrustOptedIn");function X(t){const e=t.env??process.env,r=H(t.hooks);return t.hooks.length===0?{action:"run",digest:r}:l(e.QMD_TRUST_UPDATE_HOOKS)||l(e.QMD_TRUST_LOCAL_CONFIG)?{action:"run",digest:r}:T(t.configPath)?(t.trustedCheck??_)(t.configPath,r)?{action:"run",digest:r}:{action:t.isInteractive?"prompt":"skip",digest:r}:{action:"run",digest:r}}n(X,"decideHookGate");function Y(t){const e=t.env??process.env,r=M(t.snapshot,t.configPath,t.builtins),o=O(t.configPath,t.snapshot,t.builtins);return G(o)?J(e)?{action:"run",digest:r}:T(t.configPath)?(t.trustedCheck??_)(t.configPath,r)?{action:"run",digest:r}:{action:t.isInteractive?"prompt":"skip",digest:r}:{action:"run",digest:r}:{action:"run",digest:r}}n(Y,"decideLocalConfigGate");export{X as decideHookGate,Y as decideLocalConfigGate,j as expandUserPath,O as gatedItems,R as gatedModels,k as getTrustFilePath,G as hasGatedItems,H as hookDigest,N as isCollectionPathInsideProject,T as isLocalConfigPath,J as isLocalConfigTrustOptedIn,_ as isTrusted,V as listTrusted,f as loadTrustStore,d as projectRootFromConfig,z as recordTrust,y as resolveConfigCollectionPath,B as revokeTrust,M as sensitiveDigest};

package/package.json

@@ -0,0 +1,124 @@
+{
+  "name": "ko-qmd",
+  "version": "2.8.3-ko.10",
+  "description": "Local hybrid search for Korean Markdown notes and Obsidian vaults — BM25 with Korean particle stripping, Hangul bigram FTS, Qwen3 vector search and LLM reranking, as CLI, MCP server and SDK",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "qmd": "bin/qmd"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "skills/",
+    "scripts/build.mjs",
+    "scripts/check-package-grammars.mjs",
+    "scripts/package-smoke.mjs",
+    "scripts/test-all.mjs",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "prepare": "node scripts/install-hooks.mjs && node scripts/build.mjs",
+    "build": "node scripts/build.mjs",
+    "lint": "oxlint",
+    "test": "node scripts/test-all.mjs",
+    "test:types": "node ./node_modules/typescript/bin/tsc -p tsconfig.build.json --noEmit",
+    "test:node": "node ./node_modules/vitest/vitest.mjs run --reporter=verbose --testTimeout 60000",
+    "test:bun": "bun test --timeout 60000 --preload ./src/test-preload.ts",
+    "test:unit": "CI=true node ./node_modules/vitest/vitest.mjs run --reporter=verbose --testTimeout 60000 test/ && CI=true bun test --timeout 60000 --preload ./src/test-preload.ts test/",
+    "test:package": "node scripts/package-smoke.mjs",
+    "qmd": "tsx src/cli/qmd.ts",
+    "index": "tsx src/cli/qmd.ts index",
+    "vector": "tsx src/cli/qmd.ts vector",
+    "search": "tsx src/cli/qmd.ts search",
+    "vsearch": "tsx src/cli/qmd.ts vsearch",
+    "rerank": "tsx src/cli/qmd.ts rerank",
+    "inspector": "npx @modelcontextprotocol/inspector tsx src/cli/qmd.ts mcp",
+    "release": "./scripts/release.sh",
+    "smoke:package-grammars": "node scripts/check-package-grammars.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tak-bro/ko-qmd.git"
+  },
+  "homepage": "https://github.com/tak-bro/ko-qmd#readme",
+  "bugs": {
+    "url": "https://github.com/tak-bro/ko-qmd/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/server": "2.3.1",
+    "better-sqlite3": "^13.0.3",
+    "fast-glob": "3.3.3",
+    "node-llama-cpp": "3.22.1",
+    "picomatch": "4.0.7",
+    "sqlite-vec": "0.1.9",
+    "tree-sitter-go": "0.25.0",
+    "tree-sitter-python": "0.25.0",
+    "tree-sitter-rust": "0.24.0",
+    "tree-sitter-typescript": "0.23.2",
+    "web-tree-sitter": "0.27.1",
+    "yaml": "2.9.1",
+    "zod": "4.6.6"
+  },
+  "optionalDependencies": {
+    "sqlite-vec-darwin-arm64": "0.1.9",
+    "sqlite-vec-darwin-x64": "0.1.9",
+    "sqlite-vec-linux-arm64": "0.1.9",
+    "sqlite-vec-linux-x64": "0.1.9",
+    "sqlite-vec-windows-x64": "0.1.9"
+  },
+  "devDependencies": {
+    "@oxlint/plugins": "1.87.0",
+    "@types/better-sqlite3": "7.6.13",
+    "oxlint": "1.87.0",
+    "tsx": "4.23.15",
+    "vitest": "3.2.7"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": []
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "keywords": [
+    "markdown",
+    "search",
+    "fts",
+    "full-text-search",
+    "vector",
+    "semantic-search",
+    "sqlite",
+    "bm25",
+    "embeddings",
+    "rag",
+    "mcp",
+    "reranking",
+    "knowledge-base",
+    "local-ai",
+    "llm",
+    "korean",
+    "hangul",
+    "korean-nlp",
+    "obsidian",
+    "hybrid-search",
+    "mcp-server",
+    "claude-code",
+    "qwen3"
+  ],
+  "author": "Tobi Lutke <tobi@lutke.com>",
+  "license": "MIT"
+}

package/scripts/build.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { chmodSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(fileURLToPath(new URL("..", import.meta.url)));
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit",
+    // Never shell:true — on Windows, cmd.exe splits unquoted process.execPath
+    // at spaces (C:\Program Files\nodejs\node.exe) and the build can exit 0
+    // with no dist/. spawnSync can spawn the binary + args array directly. (#681)
+    shell: false,
+    ...options,
+  });
+  if (result.error || result.status !== 0) {
+    if (result.error) {
+      console.error(`build: failed to spawn ${command}: ${result.error.message}`);
+    }
+    process.exit(result.status ?? 1);
+  }
+}
+
+run(process.execPath, [join(root, "node_modules", "typescript", "bin", "tsc"), "-p", "tsconfig.build.json"]);
+
+// Strip comments from emitted JS only (dist/**/*.js, never *.d.ts — the
+// declarations carry the SDK's API docs). Uses the TypeScript compiler API
+// with the build's own target/module so emit is identical minus trivia.
+{
+  const { createRequire } = await import("node:module");
+  const require = createRequire(import.meta.url);
+  const ts = require(join(root, "node_modules", "typescript"));
+  const { readdirSync } = await import("node:fs");
+  const jsFiles = [];
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith(".js")) jsFiles.push(p);
+    }
+  };
+  walk(join(root, "dist"));
+  for (const f of jsFiles) {
+    const src = readFileSync(f, "utf8");
+    const out = ts.transpileModule(src, {
+      // Forced ESNext: single-file transpile cannot do nodenext package-scope
+      // detection (it would emit CJS); the full-program build emits ESM here.
+      compilerOptions: { target: ts.ScriptTarget.ESNext, module: ts.ModuleKind.ESNext, removeComments: true },
+    }).outputText;
+    writeFileSync(f, out);
+  }
+  console.log(`build: stripped comments from ${jsFiles.length} JS files`);
+}
+
+// Minify emitted JS (dist/**/*.js only). esbuild comes from the dev
+// toolchain (tsx dependency) through its JS API: node_modules/.bin holds a
+// native binary on POSIX but only .cmd/.ps1 shims on Windows, which
+// spawnSync cannot run without a shell (#681). It is resolved from tsx's real
+// path because pnpm does not hoist it to node_modules/esbuild. keepNames keeps
+// top-level/function names readable in stack traces.
+{
+  const { createRequire } = await import("node:module");
+  const esbuild = createRequire(realpathSync(join(root, "node_modules", "tsx", "package.json")))("esbuild");
+  const { readdirSync } = await import("node:fs");
+  const jsFiles = [];
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith(".js")) jsFiles.push(p);
+    }
+  };
+  walk(join(root, "dist"));
+  for (const f of jsFiles) {
+    esbuild.buildSync({
+      entryPoints: [f], outfile: `${f}.min-tmp`, minify: true, keepNames: true,
+      format: "esm", target: "esnext", legalComments: "none", logLevel: "warning",
+    });
+    renameSync(`${f}.min-tmp`, f);
+  }
+  console.log(`build: minified ${jsFiles.length} JS files`);
+}
+
+const cliPath = join(root, "dist", "cli", "qmd.js");
+const tmpPath = `${cliPath}.tmp`;
+const built = readFileSync(cliPath, "utf8");
+const withoutExistingShebang = built.startsWith("#!") ? built.slice(built.indexOf("\n") + 1) : built;
+writeFileSync(tmpPath, `#!/usr/bin/env node\n${withoutExistingShebang}`);
+renameSync(tmpPath, cliPath);
+chmodSync(cliPath, 0o755);
+
+// Stamp the commit this build came from, for `qmd --version`.
+//
+// It has to happen here: a published tarball has no git history of its own, so
+// discovering the commit at runtime finds whatever repository the install
+// happens to sit inside (a global install under /opt/homebrew reported
+// Homebrew's HEAD as qmd's). See src/cli/version.ts.
+//
+// Uses spawnSync directly rather than run() above, because run() exits the
+// build on a non-zero status: no git, no repo, or a source tarball must all
+// degrade to an unstamped build, not a failed one.
+function git(args) {
+  const result = spawnSync("git", args, { cwd: root, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  if (result.status !== 0 || typeof result.stdout !== "string") return null;
+  return result.stdout.trim();
+}
+
+function buildCommit() {
+  const top = git(["rev-parse", "--show-toplevel"]);
+  // Only trust a repository that *is* this package — same rule the runtime
+  // fallback applies, so building from inside an unrelated checkout can't
+  // stamp that checkout's commit.
+  if (top === null || realpathSync(top) !== realpathSync(root)) return "";
+
+  const commit = git(["rev-parse", "--short", "HEAD"]);
+  if (!commit) return "";
+
+  // A build from a dirty tree is not the commit it claims to be; say so, so
+  // "did my install actually take?" has an answer.
+  const status = git(["status", "--porcelain"]);
+  return status ? `${commit}-dirty` : commit;
+}
+
+writeFileSync(
+  join(root, "dist", "cli", "build-info.json"),
+  `${JSON.stringify({ commit: buildCommit(), builtAt: new Date().toISOString() }, null, 2)}\n`,
+);

package/scripts/check-package-grammars.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+const grammars = [
+  "tree-sitter-typescript/tree-sitter-typescript.wasm",
+  "tree-sitter-typescript/tree-sitter-tsx.wasm",
+  "tree-sitter-python/tree-sitter-python.wasm",
+  "tree-sitter-go/tree-sitter-go.wasm",
+  "tree-sitter-rust/tree-sitter-rust.wasm",
+];
+
+let ok = true;
+for (const grammar of grammars) {
+  try {
+    const resolved = require.resolve(grammar);
+    console.log(`ok ${grammar} -> ${resolved}`);
+  } catch (err) {
+    ok = false;
+    console.error(`missing ${grammar}`);
+    console.error(err instanceof Error ? err.message : String(err));
+  }
+}
+
+if (!ok) {
+  console.error("\nAST grammar package smoke check failed. Run `bun install` locally or repair a broken global install with the matching `bun add tree-sitter-...@<version>` command shown by `qmd status`.");
+  process.exit(1);
+}

package/scripts/package-smoke.mjs

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+
+function run(label, command, args, options = {}) {
+  console.log(`==> ${label}`);
+  const { quiet, ...spawnOptions } = options;
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: quiet ? "pipe" : "inherit",
+    shell: process.platform === "win32",
+    ...spawnOptions,
+  });
+  if (result.status !== 0) {
+    console.error(`Package smoke failed: ${label}`);
+    if (quiet) {
+      if (result.stdout) process.stderr.write(result.stdout);
+      if (result.stderr) process.stderr.write(result.stderr);
+    }
+    process.exit(result.status ?? 1);
+  }
+}
+
+function assertPath(path, label = path) {
+  const full = join(root, path);
+  if (!existsSync(full)) {
+    console.error(`Package smoke failed: missing ${label} (${path})`);
+    process.exit(1);
+  }
+  return full;
+}
+
+run("build compiled package", process.execPath, ["scripts/build.mjs"]);
+run("AST grammar runtime packages", process.execPath, ["scripts/check-package-grammars.mjs"]);
+
+for (const entry of pkg.files ?? []) {
+  assertPath(entry.replace(/\/$/, ""), `package.json files[] entry ${entry}`);
+}
+
+for (const [name, binPath] of Object.entries(pkg.bin ?? {})) {
+  const full = assertPath(binPath, `bin ${name}`);
+  const mode = statSync(full).mode;
+  if ((mode & 0o111) === 0) {
+    console.error(`Package smoke failed: bin ${name} is not executable (${binPath})`);
+    process.exit(1);
+  }
+}
+
+assertPath("dist/index.js", "compiled main export");
+assertPath("dist/index.d.ts", "compiled type export");
+assertPath("dist/cli/qmd.js", "compiled CLI");
+
+run("compiled CLI under Node", process.execPath, ["dist/cli/qmd.js", "--help"], { quiet: true });
+run("package wrapper", "sh", ["bin/qmd", "--help"], { quiet: true });
+
+if (process.env.QMD_SKIP_BUN_SMOKE === "1") {
+  console.log("==> compiled CLI under Bun (skipped by QMD_SKIP_BUN_SMOKE=1)");
+} else {
+  run("compiled CLI under Bun", "bun", ["dist/cli/qmd.js", "--help"], { quiet: true });
+}

package/scripts/test-all.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+
+// Mirror bin/qmd's darwin Metal residency mitigation for test subprocesses.
+// libggml-metal asserts on a non-empty residency set during its static
+// destructor (ggml-org/llama.cpp#22593, fix open as #22595) and dumps a
+// multi-kB backtrace at process exit even when tests pass. The env var must
+// be set BEFORE the subprocess starts because libggml-metal reads it via
+// libc getenv at module-load time. Opt out with QMD_METAL_KEEP_RESIDENCY=1.
+const darwinMetalEnv =
+  process.platform === "darwin" && process.env.QMD_METAL_KEEP_RESIDENCY !== "1"
+    ? { GGML_METAL_NO_RESIDENCY: "1" }
+    : {};
+
+function run(label, command, args, options = {}) {
+  console.log(`==> ${label}`);
+  const { env: extraEnv, ...spawnOptions } = options;
+  const result = spawnSync(command, args, {
+    cwd: root,
+    stdio: "inherit",
+    shell: process.platform === "win32",
+    env: { ...process.env, ...darwinMetalEnv, ...(extraEnv ?? {}) },
+    ...spawnOptions,
+  });
+  if (result.status !== 0) {
+    console.error(`Test task failed: ${label}`);
+    process.exit(result.status ?? 1);
+  }
+}
+
+run("TypeScript build typecheck", process.execPath, [join(root, "node_modules", "typescript", "bin", "tsc"), "-p", "tsconfig.build.json", "--noEmit"]);
+run("Vitest suite under Node", process.execPath, [join(root, "node_modules", "vitest", "vitest.mjs"), "run", "--reporter=verbose", "--testTimeout", "60000", "test/"], { env: { CI: "true" } });
+// RuleTester-based custom oxlint rule tests run under plain node only:
+// vitest reports "No test suite found" and bun's runner rejects RuleTester.
+// The quoted glob is expanded by node's own test runner, not the shell.
+run("oxlint rule tests (node)", process.execPath, ["--import", "tsx", "--test", "tools/oxlint/**/*.test.ts"]);
+run("Bun test suite", "bun", ["test", "--timeout", "60000", "--preload", "./src/test-preload.ts", "test/"], { env: { CI: "true" } });
+run("Package smoke", process.execPath, ["scripts/package-smoke.mjs"]);