contentbase 0.0.2 → 0.0.4

package/src/cli/load-collection.ts

@@ -1,38 +1,132 @@
 import fs from "fs/promises";
 import path from "path";
 import { Collection } from "../collection";
+import { defineModel } from "../define-model";
+import { singularize, upperFirst } from "../utils/inflect";
+
+/**
+ * Search for a file with the given basename and common extensions.
+ */
+async function findFile(
+  dir: string,
+  basename: string
+): Promise<string | undefined> {
+  for (const ext of ["ts", "js", "mjs"]) {
+    const candidate = path.resolve(dir, `${basename}.${ext}`);
+    try {
+      await fs.stat(candidate);
+      return candidate;
+    } catch {
+      // Not found, try next
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Duck-type check: does this value look like a ModelDefinition?
+ */
+function isModelDefinition(value: unknown): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as any).name === "string" &&
+    typeof (value as any).prefix === "string" &&
+    "meta" in (value as any)
+  );
+}
+
+/**
+ * Check if a directory (up to 2 levels deep) contains .md or .mdx files.
+ */
+async function directoryContainsMarkdown(dirPath: string): Promise<boolean> {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (
+        entry.isFile() &&
+        (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))
+      ) {
+        return true;
+      }
+      if (entry.isDirectory()) {
+        const subEntries = await fs.readdir(
+          path.join(dirPath, entry.name),
+          { withFileTypes: true }
+        );
+        for (const sub of subEntries) {
+          if (
+            sub.isFile() &&
+            (sub.name.endsWith(".md") || sub.name.endsWith(".mdx"))
+          ) {
+            return true;
+          }
+        }
+      }
+    }
+  } catch {
+    // Directory unreadable
+  }
+  return false;
+}
+
+/**
+ * Tier 3: Auto-discover models from top-level subdirectories containing markdown.
+ */
+async function autoDiscoverModels(collection: Collection): Promise<number> {
+  const rootPath = collection.rootPath;
+  let registered = 0;
+
+  try {
+    const entries = await fs.readdir(rootPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dirPath = path.join(rootPath, entry.name);
+      if (await directoryContainsMarkdown(dirPath)) {
+        const folderName = entry.name;
+        const modelName = upperFirst(singularize(folderName));
+        const model = defineModel(modelName, { prefix: folderName });
+        collection.register(model);
+        registered++;
+      }
+    }
+  } catch {
+    // Root path unreadable
+  }
+
+  return registered;
+}
 
 export async function loadCollection(options: {
-  rootPath?: string;
+  contentFolder?: string;
   modulePath?: string;
 }): Promise<Collection> {
-  let { rootPath, modulePath } = options;
+  let { contentFolder, modulePath } = options;
+  let rootPath: string | undefined;
+
+  const cwd = process.cwd();
 
-  if (!rootPath) {
-    const cwd = process.cwd();
+  if (contentFolder) {
+    // Resolve relative to cwd
+    rootPath = path.resolve(cwd, contentFolder);
+  } else {
+    // Check package.json for configured content folder
     const pkgPath = path.resolve(cwd, "package.json");
     try {
       const manifest = JSON.parse(await fs.readFile(pkgPath, "utf8"));
-      if (manifest.contentbase?.rootPath) {
-        rootPath = path.resolve(cwd, manifest.contentbase.rootPath);
+      if (manifest.contentbase?.contentFolder) {
+        rootPath = path.resolve(cwd, manifest.contentbase.contentFolder);
       }
     } catch {
       // No package.json found
     }
-    rootPath = rootPath ?? cwd;
+    // Default to ./docs
+    rootPath = rootPath ?? path.resolve(cwd, "docs");
   }
 
+  // Tier 1: index.ts — full collection with models already registered
   if (!modulePath) {
-    for (const ext of ["ts", "js", "mjs"]) {
-      const candidate = path.resolve(rootPath, `index.${ext}`);
-      try {
-        await fs.stat(candidate);
-        modulePath = candidate;
-        break;
-      } catch {
-        // Not found, try next
-      }
-    }
+    modulePath = await findFile(rootPath, "index");
   }
 
   if (modulePath) {
@@ -47,7 +141,40 @@ export async function loadCollection(options: {
     return collection;
   }
 
+  // Tier 2: models.ts — import model definitions and auto-register
+  const modelsPath = await findFile(rootPath, "models");
+
+  if (modelsPath) {
+    const mod = await import(modelsPath);
+    const collection = new Collection({ rootPath });
+
+    let registered = 0;
+    for (const [, value] of Object.entries(mod)) {
+      if (isModelDefinition(value)) {
+        collection.register(value as any);
+        registered++;
+      }
+    }
+
+
+    await collection.load();
+    return collection;
+  }
+
+  // Tier 3: Auto-discover models from folder structure
   const collection = new Collection({ rootPath });
+  const discovered = await autoDiscoverModels(collection);
+
+  if (discovered > 0) {
+    console.warn(
+      `[contentbase] Auto-discovered ${discovered} model(s) from folder structure. These models have no schema validation. Create a models.ts or index.ts for proper type definitions.`
+    );
+  } else {
+    console.warn(
+      `[contentbase] No models or markdown files found in ${rootPath}. Run 'cnotes init' to set up a project.`
+    );
+  }
+
   await collection.load();
   return collection;
 }

package/src/cli/registry.ts

@@ -0,0 +1,28 @@
+import type { z } from 'zod'
+
+export interface CommandDefinition {
+  description: string
+  help?: string
+  argsSchema?: z.ZodType<any>
+  handler: (options: any, context: { container: any }) => Promise<void>
+}
+
+const registry = new Map<string, CommandDefinition>()
+
+export const commands = {
+  register(name: string, definition: CommandDefinition) {
+    registry.set(name, definition)
+  },
+
+  has(name: string): boolean {
+    return registry.has(name)
+  },
+
+  get(name: string): CommandDefinition | undefined {
+    return registry.get(name)
+  },
+
+  get available(): string[] {
+    return Array.from(registry.keys())
+  },
+}