contentbase 0.0.5 → 0.1.1

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "contentbase",
-  "version": "0.0.5",
+  "version": "0.1.1",
+  "website": "https://contentbase.soederpop.com",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -13,10 +14,11 @@
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
     "examples": "bun run scripts/examples/run-all.ts",
-    "compile": "bun build ./src/cli/index.ts --compile --outfile dist/cnotes --external @node-llama-cpp/*"
+    "compile": "bun build ./src/cli/index.ts --compile --outfile dist/cnotes --external @node-llama-cpp/*",
+    "compile:all": "bun build ./src/cli/index.ts --compile --target=bun-linux-x64 --outfile dist/cnotes-linux-x64 --external @node-llama-cpp/* && bun build ./src/cli/index.ts --compile --target=bun-linux-arm64 --outfile dist/cnotes-linux-arm64 --external @node-llama-cpp/* && bun build ./src/cli/index.ts --compile --target=bun-darwin-x64 --outfile dist/cnotes-darwin-x64 --external @node-llama-cpp/* && bun build ./src/cli/index.ts --compile --target=bun-darwin-arm64 --outfile dist/cnotes-darwin-arm64 --external @node-llama-cpp/* && bun build ./src/cli/index.ts --compile --target=bun-windows-x64 --outfile dist/cnotes-windows-x64.exe --external @node-llama-cpp/*"
   },
   "dependencies": {
-    "@soederpop/luca": "^0.0.2",
+    "@soederpop/luca": "latest",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
     "mdast-util-mdxjs-esm": "^2.0.1",

package/src/cli/commands/index.ts

@@ -15,3 +15,4 @@ import './help.js'
 import './text-search.js'
 import './search.js'
 import './embed.js'
+import './update.js'

package/src/cli/commands/update.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod'
+import picomatch from 'picomatch'
+import { commands } from '../registry.js'
+import { loadCollection } from '../load-collection.js'
+
+const argsSchema = z.object({
+  contentFolder: z.string().optional(),
+  force: z.boolean().default(false),
+  dry: z.boolean().default(false),
+})
+
+/**
+ * Parse "meta.status=spark" into a nested path assignment.
+ * Supports dotted paths like "meta.status" or bare keys like "status"
+ * (bare keys are treated as meta.<key>).
+ */
+function parseAssignment(raw: string): { path: string[]; value: string } | null {
+  const eqIdx = raw.indexOf('=')
+  if (eqIdx === -1) return null
+
+  const key = raw.slice(0, eqIdx).trim()
+  const value = raw.slice(eqIdx + 1).trim()
+
+  // Normalise: if path doesn't start with "meta.", prepend it
+  const fullKey = key.startsWith('meta.') ? key : `meta.${key}`
+  const path = fullKey.split('.')
+
+  return { path, value }
+}
+
+/**
+ * Coerce a string value to a JS primitive if it looks like one.
+ */
+function coerceValue(raw: string): unknown {
+  if (raw === 'true') return true
+  if (raw === 'false') return false
+  if (raw === 'null') return null
+  if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw)
+  return raw
+}
+
+/**
+ * Set a nested value on an object via a path array.
+ * e.g. setNested(obj, ['meta', 'status'], 'spark') → obj.meta.status = 'spark'
+ */
+function setNested(obj: Record<string, any>, path: string[], value: unknown) {
+  let current = obj
+  for (let i = 1; i < path.length - 1; i++) {
+    if (!(path[i] in current) || typeof current[path[i]] !== 'object') {
+      current[path[i]] = {}
+    }
+    current = current[path[i]]
+  }
+  current[path[path.length - 1]] = value
+}
+
+async function handler(options: z.infer<typeof argsSchema>, context: { container: any }) {
+  const { container } = context
+  const args: string[] = container.argv._.slice(1) // everything after "update"
+
+  if (args.length < 2) {
+    console.error('Usage: cnotes update <glob> <key=value> [key=value ...] [--force] [--dry]')
+    process.exit(1)
+  }
+
+  const globPattern = args[0]
+  const assignments = args.slice(1).map(parseAssignment).filter(Boolean) as { path: string[]; value: string }[]
+
+  if (assignments.length === 0) {
+    console.error('No valid key=value assignments found. Use format: meta.status=spark')
+    process.exit(1)
+  }
+
+  const collection = await loadCollection({
+    contentFolder: options.contentFolder,
+  })
+
+  // Match pathIds against the glob pattern
+  const isMatch = picomatch(globPattern)
+  const matchedIds = collection.available.filter((id) => isMatch(id))
+
+  if (matchedIds.length === 0) {
+    console.log(`No documents matched "${globPattern}"`)
+    return
+  }
+
+  console.log(`Matched ${matchedIds.length} document(s)\n`)
+
+  let updated = 0
+  let skipped = 0
+  let validationErrors = 0
+
+  for (const pathId of matchedIds) {
+    const doc = collection.document(pathId)
+    const def = collection.findModelDefinition(pathId)
+
+    // Apply assignments to a draft copy of meta for validation
+    const draftMeta = structuredClone(doc.meta) as Record<string, any>
+    for (const { path, value } of assignments) {
+      setNested({ meta: draftMeta }, ['meta', ...path.slice(1)], coerceValue(value))
+    }
+
+    // Validate unless --force
+    if (!options.force && def) {
+      const rawMeta = { ...(def.defaults ?? {}), ...draftMeta }
+      const metaResult = def.meta.safeParse(rawMeta)
+
+      if (!metaResult.success) {
+        validationErrors++
+        console.log(`INVALID: ${pathId}`)
+        for (const issue of metaResult.error.issues) {
+          console.log(`  ${issue.path.join('.')}: ${issue.message}`)
+        }
+        continue
+      }
+    }
+
+    if (options.dry) {
+      console.log(`WOULD UPDATE: ${pathId}`)
+      for (const { path, value } of assignments) {
+        console.log(`  ${path.join('.')} = ${value}`)
+      }
+      updated++
+      continue
+    }
+
+    // Apply to the real document
+    for (const { path, value } of assignments) {
+      setNested({ meta: doc.meta as Record<string, any> }, ['meta', ...path.slice(1)], coerceValue(value))
+    }
+
+    await doc.save({ normalize: false })
+    updated++
+    console.log(`UPDATED: ${pathId}`)
+  }
+
+  console.log()
+  console.log(`${updated} updated, ${validationErrors} invalid, ${matchedIds.length - updated - validationErrors} skipped`)
+}
+
+commands.register('update', {
+  description: 'Bulk-update document frontmatter by glob pattern',
+  help: `# cnotes update
+
+Bulk-update frontmatter fields on documents matching a glob pattern. Validates changes against the model schema before writing (bypass with \`--force\`).
+
+## Usage
+
+\`\`\`
+cnotes update <glob> <key=value> [key=value ...] [options]
+\`\`\`
+
+## Arguments
+
+| Argument | Description |
+|----------|-------------|
+| \`glob\` | Glob pattern to match document path IDs (e.g. \`docs/ideas/**\`) |
+| \`key=value\` | One or more assignments. Prefix with \`meta.\` or use bare keys (auto-prefixed). |
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| \`--force\` | Skip schema validation |
+| \`--dry\` | Preview changes without writing |
+| \`--contentFolder\` | Path to content folder |
+
+## Examples
+
+\`\`\`bash
+# Set status on all ideas
+cnotes update "ideas/**" meta.status=spark
+
+# Multiple fields at once
+cnotes update "epics/*" status=approved priority=high
+
+# Preview what would change
+cnotes update "ideas/**" status=spark --dry
+
+# Force past schema validation
+cnotes update "ideas/**" status=spark --force
+\`\`\`
+`,
+  argsSchema,
+  handler,
+})

package/src/cli/load-collection.ts

@@ -1,8 +1,10 @@
 import fs from "fs/promises";
 import path from "path";
+import { existsSync } from "fs";
 import { Collection } from "../collection";
 import { defineModel } from "../define-model";
 import { singularize, upperFirst } from "../utils/inflect";
+import * as contentbaseExports from "../index";
 
 /**
  * Search for a file with the given basename and common extensions.
@@ -97,15 +99,55 @@ async function autoDiscoverModels(collection: Collection): Promise<number> {
   return registered;
 }
 
+/** Seed the luca VM with contentbase and common deps so models.ts can resolve imports */
+function seedContentbaseModules(container: any): void {
+  const vm = container.feature('vm')
+
+  // Seed luca modules first
+  const helpers = container.feature('helpers')
+  if (helpers?.seedVirtualModules) {
+    helpers.seedVirtualModules()
+  }
+
+  vm.defineModule('contentbase', contentbaseExports)
+  try { vm.defineModule('js-yaml', require('js-yaml')) } catch {}
+  try { vm.defineModule('mdast-util-to-string', require('mdast-util-to-string')) } catch {}
+}
+
+/** Build a VM-backed module loader using the luca container */
+function createVmModuleLoader(container: any): (filePath: string) => Record<string, any> {
+  let seeded = false
+  return (filePath: string) => {
+    if (!seeded) {
+      seedContentbaseModules(container)
+      seeded = true
+    }
+    return container.feature('vm').loadModule(filePath)
+  }
+}
+
 export async function loadCollection(options: {
   contentFolder?: string;
   modulePath?: string;
+  container?: any;
 }): Promise<Collection> {
   let { contentFolder, modulePath } = options;
+  let container = options.container;
   let rootPath: string | undefined;
 
   const cwd = process.cwd();
 
+  // If no container was passed, try to grab the luca singleton.
+  // This works when running inside the cnotes CLI (which imports @soederpop/luca/node).
+  if (!container) {
+    try {
+      const luca = await import('@soederpop/luca/node');
+      container = luca.default;
+    } catch {
+      // Not running in a luca context — that's fine, native imports will be used
+    }
+  }
+
   if (contentFolder) {
     // Resolve relative to cwd
     rootPath = path.resolve(cwd, contentFolder);
@@ -124,13 +166,25 @@ export async function loadCollection(options: {
     rootPath = rootPath ?? path.resolve(cwd, "docs");
   }
 
+  // Determine if we need a VM-based loader (no contentbase in node_modules)
+  const needsVmLoader = container?.feature && !existsSync(path.resolve(cwd, "node_modules", "contentbase"));
+  const moduleLoader = needsVmLoader ? createVmModuleLoader(container) : undefined;
+
+  // Helper to import a module file, falling back to VM when needed
+  const importModule = async (filePath: string): Promise<Record<string, any>> => {
+    if (moduleLoader) {
+      return moduleLoader(filePath);
+    }
+    return import(filePath);
+  };
+
   // Tier 1: index.ts — full collection with models already registered
   if (!modulePath) {
     modulePath = await findFile(rootPath, "index");
   }
 
   if (modulePath) {
-    const mod = await import(modulePath);
+    const mod = await importModule(modulePath);
     const collection = mod.collection ?? mod.default;
     if (!(collection instanceof Collection)) {
       throw new Error(
@@ -145,8 +199,8 @@ export async function loadCollection(options: {
   const modelsPath = await findFile(rootPath, "models");
 
   if (modelsPath) {
-    const mod = await import(modelsPath);
-    const collection = new Collection({ rootPath });
+    const mod = await importModule(modelsPath);
+    const collection = new Collection({ rootPath, moduleLoader });
 
     let registered = 0;
     for (const [, value] of Object.entries(mod)) {
@@ -156,13 +210,12 @@ export async function loadCollection(options: {
       }
     }
 
-
     await collection.load();
     return collection;
   }
 
   // Tier 3: Auto-discover models from folder structure
-  const collection = new Collection({ rootPath });
+  const collection = new Collection({ rootPath, moduleLoader });
   const discovered = await autoDiscoverModels(collection);
 
   if (discovered > 0) {

package/src/collection.ts

@@ -117,12 +117,14 @@ export class Collection {
     new Map();
   #loaded = false;
   #autoDiscover: boolean;
+  #moduleLoader?: (filePath: string) => Record<string, any> | Promise<Record<string, any>>;
 
   constructor(options: CollectionOptions) {
     this.rootPath = path.resolve(options.rootPath);
     this.name = options.name ?? options.rootPath;
     this.extensions = options.extensions ?? ["mdx", "md"];
     this.#autoDiscover = options.autoDiscover ?? true;
+    this.#moduleLoader = options.moduleLoader;
   }
 
   // ─── Model registration ───
@@ -159,7 +161,9 @@ export class Collection {
     for (const ext of ["ts", "js", "mjs"]) {
       const candidate = path.resolve(this.rootPath, `models.${ext}`);
       try {
-        const mod = await import(candidate);
+        const mod = this.#moduleLoader
+          ? await this.#moduleLoader(candidate)
+          : await import(candidate);
         for (const value of Object.values(mod)) {
           if (isModelDefinition(value) && !this.#models.has((value as any).name)) {
             this.register(value as any);

package/src/types.ts

@@ -22,6 +22,8 @@ export interface CollectionOptions {
   name?: string;
   /** When true (default), load() looks for a models.{ts,js,mjs} in rootPath and auto-registers exported model definitions. */
   autoDiscover?: boolean;
+  /** Optional custom module loader for models.ts discovery. When provided, used instead of native import(). Enables VM-based loading in compiled binaries where node_modules aren't available. */
+  moduleLoader?: (filePath: string) => Record<string, any> | Promise<Record<string, any>>;
 }
 
 // ─── Section system ───