unrag 0.1.1

package/README.md

@@ -0,0 +1,47 @@
+# Unrag
+
+Unrag is a **RAG installer** for TypeScript projects that installs **composable, drop-in primitives** as source files you own.
+
+It installs small, auditable source files into your repo:
+- `unrag.config.ts` (project root)
+- `lib/unrag/**` (or your chosen directory)
+- `lib/unrag/unrag.md` (setup notes + schema)
+
+## Usage
+
+```bash
+bunx unrag init
+```
+
+### Common flags
+
+```bash
+bunx unrag init --yes --store drizzle --dir lib/unrag --alias @unrag
+```
+
+- `--store`: `drizzle` | `prisma` | `raw-sql`
+- `--dir`: where to install the module code (default `lib/unrag`)
+- `--alias`: import alias base (default `@unrag`) used to patch `tsconfig.json` in Next.js projects
+
+## After install
+
+Import the engine from your project root config:
+
+```ts
+import { createUnragEngine } from "@unrag/config";
+```
+
+Then use the primitives:
+
+```ts
+const engine = createUnragEngine();
+await engine.ingest({ sourceId: "doc-1", content: "..." });
+const result = await engine.retrieve({ query: "search", topK: 5 });
+```
+
+## Database
+
+Unrag assumes **Postgres + pgvector**. You manage migrations yourself.
+See the installed `lib/unrag/unrag.md` for the expected schema and indexes.
+
+

package/dist/cli/index.js

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+
+// cli/run.ts
+import { intro, outro as outro2 } from "@clack/prompts";
+
+// cli/commands/init.ts
+import { cancel as cancel2, isCancel as isCancel2, outro, select, text } from "@clack/prompts";
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// cli/lib/registry.ts
+import path2 from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { confirm, isCancel, cancel } from "@clack/prompts";
+
+// cli/lib/fs.ts
+import { access, mkdir, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+function normalizePosixPath(p) {
+  return p.replace(/\\/g, "/").replace(/\/+$/, "");
+}
+async function tryFindProjectRoot(startDir) {
+  return findUp(startDir, "package.json");
+}
+async function findUp(startDir, filename) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const candidate = path.join(current, filename);
+    if (await exists(candidate)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// cli/lib/registry.ts
+var readText = (filePath) => readFile(filePath, "utf8");
+var writeText = async (filePath, content) => {
+  await ensureDir(path2.dirname(filePath));
+  await writeFile(filePath, content, "utf8");
+};
+var renderUnragConfig = (content, selection) => {
+  const installImportBase = `./${selection.installDir.replace(/\\/g, "/")}`;
+  const baseImports = [
+    `import { createContextEngine, defineConfig } from "${installImportBase}/core";`,
+    `import { createAiEmbeddingProvider } from "${installImportBase}/embedding/ai";`
+  ];
+  const storeImports = [];
+  const storeCreateLines = [];
+  if (selection.storeAdapter === "drizzle") {
+    storeImports.push(`import { createDrizzleVectorStore } from "${installImportBase}/store/drizzle";`, `import { drizzle } from "drizzle-orm/node-postgres";`, `import { Pool } from "pg";`);
+    storeCreateLines.push(`  const databaseUrl = process.env.DATABASE_URL;`, `  if (!databaseUrl) throw new Error("DATABASE_URL is required");`, ``, `  const pool = (globalThis as any).__unragPool ?? new Pool({ connectionString: databaseUrl });`, `  (globalThis as any).__unragPool = pool;`, ``, `  const db = (globalThis as any).__unragDrizzleDb ?? drizzle(pool);`, `  (globalThis as any).__unragDrizzleDb = db;`, ``, `  const store = createDrizzleVectorStore(db);`);
+  } else if (selection.storeAdapter === "raw-sql") {
+    storeImports.push(`import { createRawSqlVectorStore } from "${installImportBase}/store/raw-sql";`, `import { Pool } from "pg";`);
+    storeCreateLines.push(`  const databaseUrl = process.env.DATABASE_URL;`, `  if (!databaseUrl) throw new Error("DATABASE_URL is required");`, ``, `  const pool = (globalThis as any).__unragPool ?? new Pool({ connectionString: databaseUrl });`, `  (globalThis as any).__unragPool = pool;`, ``, `  const store = createRawSqlVectorStore(pool);`);
+  } else {
+    storeImports.push(`import { createPrismaVectorStore } from "${installImportBase}/store/prisma";`, `import { PrismaClient } from "@prisma/client";`);
+    storeCreateLines.push(`  const prisma = (globalThis as any).__unragPrisma ?? new PrismaClient();`, `  (globalThis as any).__unragPrisma = prisma;`, `  const store = createPrismaVectorStore(prisma);`);
+  }
+  const importsBlock = [...baseImports, ...storeImports].join(`
+`);
+  const createEngineBlock = [
+    `export function createUnragEngine() {`,
+    `  const embedding = createAiEmbeddingProvider({`,
+    `    model: unragConfig.embedding.model,`,
+    `    timeoutMs: unragConfig.embedding.timeoutMs,`,
+    `  });`,
+    ...storeCreateLines,
+    ``,
+    `  return createContextEngine(`,
+    `    defineConfig({`,
+    `      embedding,`,
+    `      store,`,
+    `      defaults: unragConfig.chunking,`,
+    `    })`,
+    `  );`,
+    `}`,
+    ``,
+    `export async function retrieve(query: string) {`,
+    `  const engine = createUnragEngine();`,
+    `  return engine.retrieve({ query, topK: unragConfig.retrieval.topK });`,
+    `}`
+  ].join(`
+`);
+  return content.replace("// __UNRAG_IMPORTS__", importsBlock).replace("// __UNRAG_CREATE_ENGINE__", createEngineBlock);
+};
+var renderDocs = (content, selection) => {
+  const notes = [];
+  if (selection.storeAdapter === "drizzle") {
+    notes.push("## Store adapter: Drizzle", "", "You can import the generated Drizzle schema module into your app’s main Drizzle schema to avoid duplicating table definitions.", "", "Example pattern:", "```ts", `import * as rag from "./${selection.installDir}/store/drizzle/schema";`, "", "export const schema = {", "  ...rag.schema,", "  // ...your app tables", "};", "```", "", "Then run Drizzle migrations from your app as usual.");
+  } else if (selection.storeAdapter === "prisma") {
+    notes.push("## Store adapter: Prisma", "", "This adapter uses `prisma.$executeRaw` / `prisma.$queryRaw` so you can keep your Prisma models minimal or skip them entirely.", "", 'If you want Prisma models, pgvector is typically represented as `Unsupported("vector")`.', "You can still run migrations however you prefer (SQL migrations are the simplest for pgvector).");
+  } else {
+    notes.push("## Store adapter: Raw SQL", "", "This adapter uses a `pg` Pool and parameterized SQL queries against the tables described above.", "It’s the most portable option when you don’t want ORM coupling.");
+  }
+  const withNotes = content.replace("<!-- __UNRAG_ADAPTER_NOTES__ -->", notes.join(`
+`));
+  return withNotes.replaceAll("@unrag/config", `${selection.aliasBase}/config`).replaceAll("`@unrag/*`", `\`${selection.aliasBase}/*\``);
+};
+async function copyRegistryFiles(selection) {
+  const toAbs = (projectRelative) => path2.join(selection.projectRoot, projectRelative);
+  const installBaseAbs = toAbs(selection.installDir);
+  const fileMappings = [
+    {
+      src: path2.join(selection.registryRoot, "config/unrag.config.ts"),
+      dest: toAbs("unrag.config.ts"),
+      transform: (c) => renderUnragConfig(c, selection)
+    },
+    {
+      src: path2.join(selection.registryRoot, "docs/unrag.md"),
+      dest: path2.join(installBaseAbs, "unrag.md"),
+      transform: (c) => renderDocs(c, selection)
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/index.ts"),
+      dest: path2.join(installBaseAbs, "core/index.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/types.ts"),
+      dest: path2.join(installBaseAbs, "core/types.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/chunking.ts"),
+      dest: path2.join(installBaseAbs, "core/chunking.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/config.ts"),
+      dest: path2.join(installBaseAbs, "core/config.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/context-engine.ts"),
+      dest: path2.join(installBaseAbs, "core/context-engine.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/ingest.ts"),
+      dest: path2.join(installBaseAbs, "core/ingest.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "core/retrieve.ts"),
+      dest: path2.join(installBaseAbs, "core/retrieve.ts")
+    },
+    {
+      src: path2.join(selection.registryRoot, "embedding/ai.ts"),
+      dest: path2.join(installBaseAbs, "embedding/ai.ts")
+    }
+  ];
+  if (selection.storeAdapter === "drizzle") {
+    fileMappings.push({
+      src: path2.join(selection.registryRoot, "store/drizzle-postgres-pgvector/index.ts"),
+      dest: path2.join(installBaseAbs, "store/drizzle/index.ts")
+    }, {
+      src: path2.join(selection.registryRoot, "store/drizzle-postgres-pgvector/schema.ts"),
+      dest: path2.join(installBaseAbs, "store/drizzle/schema.ts")
+    }, {
+      src: path2.join(selection.registryRoot, "store/drizzle-postgres-pgvector/store.ts"),
+      dest: path2.join(installBaseAbs, "store/drizzle/store.ts")
+    });
+  } else if (selection.storeAdapter === "raw-sql") {
+    fileMappings.push({
+      src: path2.join(selection.registryRoot, "store/raw-sql-postgres-pgvector/index.ts"),
+      dest: path2.join(installBaseAbs, "store/raw-sql/index.ts")
+    }, {
+      src: path2.join(selection.registryRoot, "store/raw-sql-postgres-pgvector/store.ts"),
+      dest: path2.join(installBaseAbs, "store/raw-sql/store.ts")
+    });
+  } else {
+    fileMappings.push({
+      src: path2.join(selection.registryRoot, "store/prisma-postgres-pgvector/index.ts"),
+      dest: path2.join(installBaseAbs, "store/prisma/index.ts")
+    }, {
+      src: path2.join(selection.registryRoot, "store/prisma-postgres-pgvector/store.ts"),
+      dest: path2.join(installBaseAbs, "store/prisma/store.ts")
+    });
+  }
+  for (const mapping of fileMappings) {
+    if (!await exists(mapping.src)) {
+      throw new Error(`Registry file missing: ${mapping.src}`);
+    }
+    if (await exists(mapping.dest)) {
+      const answer = await confirm({
+        message: `Overwrite ${path2.relative(selection.projectRoot, mapping.dest)}?`,
+        initialValue: false
+      });
+      if (isCancel(answer)) {
+        cancel("Cancelled.");
+        return;
+      }
+      if (!answer) {
+        continue;
+      }
+    }
+    const raw = await readText(mapping.src);
+    const content = mapping.transform ? mapping.transform(raw) : raw;
+    await writeText(mapping.dest, content);
+  }
+}
+
+// cli/lib/json.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+async function readJsonFile(filePath) {
+  try {
+    const raw = await readFile2(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await writeFile2(filePath, JSON.stringify(data, null, 2) + `
+`, "utf8");
+}
+
+// cli/lib/packageJson.ts
+import path3 from "node:path";
+import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+async function detectPackageManager(projectRoot) {
+  if (await exists(path3.join(projectRoot, "bun.lock")))
+    return "bun";
+  if (await exists(path3.join(projectRoot, "pnpm-lock.yaml")))
+    return "pnpm";
+  if (await exists(path3.join(projectRoot, "yarn.lock")))
+    return "yarn";
+  if (await exists(path3.join(projectRoot, "package-lock.json")))
+    return "npm";
+  return "npm";
+}
+async function readPackageJson(projectRoot) {
+  const raw = await readFile3(path3.join(projectRoot, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+async function writePackageJson(projectRoot, pkg) {
+  await writeFile3(path3.join(projectRoot, "package.json"), JSON.stringify(pkg, null, 2) + `
+`, "utf8");
+}
+function mergeDeps(pkg, deps, devDeps) {
+  const next = { ...pkg };
+  next.dependencies = { ...pkg.dependencies ?? {} };
+  next.devDependencies = { ...pkg.devDependencies ?? {} };
+  const changes = [];
+  for (const [name, version] of Object.entries(deps)) {
+    if (!next.dependencies[name] && !next.devDependencies[name]) {
+      next.dependencies[name] = version;
+      changes.push({ name, version, kind: "dep" });
+    }
+  }
+  for (const [name, version] of Object.entries(devDeps)) {
+    if (!next.dependencies[name] && !next.devDependencies[name]) {
+      next.devDependencies[name] = version;
+      changes.push({ name, version, kind: "devDep" });
+    }
+  }
+  return { pkg: next, changes };
+}
+function depsForAdapter(adapter) {
+  const deps = {
+    ai: "^5.0.113"
+  };
+  const devDeps = {};
+  if (adapter === "drizzle") {
+    deps["drizzle-orm"] = "^0.45.1";
+    deps["pg"] = "^8.16.3";
+    devDeps["@types/pg"] = "^8.16.0";
+  }
+  if (adapter === "raw-sql") {
+    deps["pg"] = "^8.16.3";
+    devDeps["@types/pg"] = "^8.16.0";
+  }
+  if (adapter === "prisma") {
+    deps["@prisma/client"] = "^6.0.0";
+    devDeps["prisma"] = "^6.0.0";
+  }
+  return { deps, devDeps };
+}
+function installCmd(pm) {
+  if (pm === "bun")
+    return "bun install";
+  if (pm === "pnpm")
+    return "pnpm install";
+  if (pm === "yarn")
+    return "yarn";
+  return "npm install";
+}
+
+// cli/lib/tsconfig.ts
+import path4 from "node:path";
+import { readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { parse } from "jsonc-parser";
+var parseJsoncLoose = (raw) => {
+  const errors = [];
+  const result = parse(raw, errors, { allowTrailingComma: true });
+  if (errors.length > 0 || !result || typeof result !== "object") {
+    throw new Error("Failed to parse tsconfig JSONC");
+  }
+  return result;
+};
+async function patchTsconfigPaths(params) {
+  const configFile = await exists(path4.join(params.projectRoot, "tsconfig.json")) ? "tsconfig.json" : await exists(path4.join(params.projectRoot, "jsconfig.json")) ? "jsconfig.json" : null;
+  const aliasBase = params.aliasBase;
+  const aliasKey = `${aliasBase}/*`;
+  const target = [`./${params.installDir.replace(/\\/g, "/")}/*`];
+  const configAliasKey = `${aliasBase}/config`;
+  const configTarget = ["./unrag.config.ts"];
+  if (!configFile) {
+    const abs2 = path4.join(params.projectRoot, "tsconfig.json");
+    const next2 = {
+      compilerOptions: {
+        baseUrl: ".",
+        paths: {
+          [aliasKey]: target,
+          [configAliasKey]: configTarget
+        }
+      }
+    };
+    await writeFile4(abs2, JSON.stringify(next2, null, 2) + `
+`, "utf8");
+    return { changed: true, file: "tsconfig.json" };
+  }
+  const abs = path4.join(params.projectRoot, configFile);
+  const raw = await readFile4(abs, "utf8");
+  let parsed;
+  try {
+    parsed = parseJsoncLoose(raw);
+  } catch {
+    return { changed: false, file: configFile };
+  }
+  const next = { ...parsed };
+  next.compilerOptions = parsed.compilerOptions && typeof parsed.compilerOptions === "object" ? { ...parsed.compilerOptions } : {};
+  const parsedPaths = next.compilerOptions.paths && typeof next.compilerOptions.paths === "object" ? next.compilerOptions.paths : {};
+  next.compilerOptions.paths = { ...parsedPaths };
+  const hasBaseUrl = typeof next.compilerOptions.baseUrl === "string" && next.compilerOptions.baseUrl.length > 0;
+  const hasRagAlias = Array.isArray(next.compilerOptions.paths[aliasKey]);
+  const hasRagConfigAlias = Array.isArray(next.compilerOptions.paths[configAliasKey]);
+  const needsWrite = !hasBaseUrl || !hasRagAlias || !hasRagConfigAlias;
+  if (!needsWrite)
+    return { changed: false, file: configFile };
+  if (!hasBaseUrl) {
+    next.compilerOptions.baseUrl = ".";
+  }
+  if (!hasRagAlias) {
+    next.compilerOptions.paths[aliasKey] = target;
+  }
+  if (!hasRagConfigAlias) {
+    next.compilerOptions.paths[configAliasKey] = configTarget;
+  }
+  await writeFile4(abs, JSON.stringify(next, null, 2) + `
+`, "utf8");
+  return { changed: true, file: configFile };
+}
+
+// cli/commands/init.ts
+var CONFIG_FILE = "unrag.json";
+var CONFIG_VERSION = 1;
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+var parseInitArgs = (args) => {
+  const out = {};
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    if (a === "--yes" || a === "-y") {
+      out.yes = true;
+      continue;
+    }
+    if (a === "--dir" || a === "--install-dir") {
+      const v = args[i + 1];
+      if (v) {
+        out.installDir = v;
+        i++;
+      }
+      continue;
+    }
+    if (a === "--store") {
+      const v = args[i + 1];
+      if (v === "drizzle" || v === "prisma" || v === "raw-sql") {
+        out.storeAdapter = v;
+        i++;
+      }
+      continue;
+    }
+    if (a === "--alias") {
+      const v = args[i + 1];
+      if (v) {
+        out.aliasBase = v;
+        i++;
+      }
+      continue;
+    }
+  }
+  return out;
+};
+async function initCommand(args) {
+  const root = await tryFindProjectRoot(process.cwd());
+  if (!root) {
+    throw new Error("Could not find a project root (no package.json found).");
+  }
+  const cliPackageRoot = await findUp(__dirname2, "package.json");
+  if (!cliPackageRoot) {
+    throw new Error("Could not locate CLI package root (package.json not found).");
+  }
+  const registryRoot = path5.join(cliPackageRoot, "registry");
+  const existing = await readJsonFile(path5.join(root, CONFIG_FILE));
+  const parsed = parseInitArgs(args);
+  const defaults = {
+    installDir: existing?.installDir ?? "lib/unrag",
+    storeAdapter: existing?.storeAdapter ?? "drizzle",
+    aliasBase: existing?.aliasBase ?? "@unrag"
+  };
+  const nonInteractive = parsed.yes || !process.stdin.isTTY;
+  const installDirAnswer = parsed.installDir ? parsed.installDir : nonInteractive ? defaults.installDir : await text({
+    message: "Install directory",
+    initialValue: defaults.installDir,
+    validate: (v) => {
+      if (!v.trim())
+        return "Install directory is required";
+      if (v.startsWith("/"))
+        return "Use a project-relative path";
+      return;
+    }
+  });
+  if (isCancel2(installDirAnswer)) {
+    cancel2("Cancelled.");
+    return;
+  }
+  const installDir = normalizePosixPath(String(installDirAnswer));
+  const storeAdapterAnswer = parsed.storeAdapter ? parsed.storeAdapter : nonInteractive ? defaults.storeAdapter : await select({
+    message: "Store adapter",
+    initialValue: defaults.storeAdapter,
+    options: [
+      { value: "drizzle", label: "Drizzle (Postgres + pgvector)" },
+      { value: "prisma", label: "Prisma (Postgres + pgvector)" },
+      { value: "raw-sql", label: "Raw SQL (Postgres + pgvector)" }
+    ]
+  });
+  if (isCancel2(storeAdapterAnswer)) {
+    cancel2("Cancelled.");
+    return;
+  }
+  const aliasAnswer = parsed.aliasBase ? parsed.aliasBase : nonInteractive ? defaults.aliasBase : await text({
+    message: "Import alias base",
+    initialValue: defaults.aliasBase,
+    validate: (v) => {
+      const s = v.trim();
+      if (!s)
+        return "Alias is required";
+      if (s.includes(" "))
+        return "Alias must not contain spaces";
+      if (!s.startsWith("@"))
+        return 'Alias should start with "@" (e.g. "@unrag")';
+      if (s.endsWith("/"))
+        return "Alias must not end with /";
+      return;
+    }
+  });
+  if (isCancel2(aliasAnswer)) {
+    cancel2("Cancelled.");
+    return;
+  }
+  const aliasBase = String(aliasAnswer).trim();
+  const selection = {
+    installDir,
+    storeAdapter: storeAdapterAnswer,
+    projectRoot: root,
+    registryRoot,
+    aliasBase
+  };
+  await copyRegistryFiles(selection);
+  const pkg = await readPackageJson(root);
+  const { deps, devDeps } = depsForAdapter(storeAdapterAnswer);
+  const merged = mergeDeps(pkg, deps, devDeps);
+  if (merged.changes.length > 0) {
+    await writePackageJson(root, merged.pkg);
+  }
+  const config = {
+    installDir,
+    storeAdapter: storeAdapterAnswer,
+    aliasBase,
+    version: CONFIG_VERSION
+  };
+  await writeJsonFile(path5.join(root, CONFIG_FILE), config);
+  const pm = await detectPackageManager(root);
+  const installLine = merged.changes.length > 0 ? `Next: run \`${installCmd(pm)}\`` : "Dependencies already satisfied.";
+  const isNext = Boolean((merged.pkg.dependencies ?? {})["next"]) || Boolean((merged.pkg.devDependencies ?? {})["next"]);
+  const tsconfigResult = isNext ? await patchTsconfigPaths({ projectRoot: root, installDir, aliasBase }) : { changed: false };
+  outro([
+    "Installed Unrag.",
+    "",
+    `- Code: ${path5.join(installDir)}`,
+    `- Docs: ${path5.join(installDir, "unrag.md")}`,
+    `- Config: unrag.config.ts`,
+    `- Imports: ${aliasBase}/* and ${aliasBase}/config`,
+    isNext ? tsconfigResult.changed ? `- Next.js: updated ${tsconfigResult.file} (added aliases)` : `- Next.js: no tsconfig changes needed` : `- Next.js: not detected`,
+    "",
+    merged.changes.length > 0 ? `Added deps: ${merged.changes.map((c) => c.name).join(", ")}` : "Added deps: none",
+    installLine,
+    "",
+    `Saved ${CONFIG_FILE}.`
+  ].join(`
+`));
+}
+
+// cli/run.ts
+async function run(argv) {
+  const [, , command, ...rest] = argv;
+  intro("unrag");
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    outro2("Usage: unrag init");
+    return;
+  }
+  if (command === "init") {
+    await initCommand(rest);
+    return;
+  }
+  outro2(`Unknown command: ${command}`);
+  process.exitCode = 1;
+}
+
+// cli/index.ts
+run(process.argv).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "unrag",
+  "type": "module",
+  "bin": {
+    "unrag": "./dist/cli/index.js"
+  },
+  "version": "0.1.1",
+  "private": false,
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/pg": "^8.16.0",
+    "@prisma/client": "^6.0.0",
+    "prisma": "^6.0.0",
+    "drizzle-orm": "^0.45.1",
+    "drizzle-kit": "^0.31.8",
+    "ai": "^5.0.113",
+    "pg": "^8.16.3"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "jsonc-parser": "^3.3.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "scripts": {
+    "build": "bun build --target=node --format=esm --packages=external --outfile dist/cli/index.js cli/index.ts",
+    "test": "bun test"
+  },
+  "files": [
+    "dist/**",
+    "registry/**",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/registry/config/unrag.config.ts

@@ -0,0 +1,32 @@
+/**
+ * Root Unrag config (generated).
+ *
+ * This file is meant to be the single place you tweak:
+ * - Embedding provider/model/timeouts
+ * - Chunking defaults
+ * - Retrieval defaults
+ * - How you construct your DB client (Pool/Prisma/etc)
+ *
+ * The files under your install dir (e.g. `lib/unrag/**`) are intended to be
+ * treated like vendored source code.
+ */
+
+// __UNRAG_IMPORTS__
+
+export const unragConfig = {
+  chunking: {
+    chunkSize: 200,
+    chunkOverlap: 40,
+  },
+  retrieval: {
+    topK: 8,
+  },
+  embedding: {
+    model: "openai/text-embedding-3-small",
+    timeoutMs: 15_000,
+  },
+} as const;
+
+// __UNRAG_CREATE_ENGINE__
+
+