adonia 0.1.0

package/build/registry/index.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CORE_PACKAGES, impliedCoreManifest, moduleManifestSchema, registryIndexSchema, } from '../schema.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function bundledRegistryPath() {
+    // build/registry/index.js → ../../registry
+    return resolve(__dirname, '../../registry');
+}
+export function loadRegistryIndex(root) {
+    const path = join(root, 'registry.json');
+    if (!existsSync(path)) {
+        const names = readdirSync(root).filter((n) => {
+            try {
+                return statSync(join(root, n)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        const core = ['api', ...CORE_PACKAGES].filter((n) => names.includes(n));
+        const modules = names.filter((n) => !core.includes(n) && existsSync(join(root, n, 'module.json')));
+        return registryIndexSchema.parse({ core, modules });
+    }
+    return registryIndexSchema.parse(JSON.parse(readFileSync(path, 'utf8')));
+}
+/**
+ * Resolution order:
+ * 1. --registry <dir>
+ * 2. bundled (adonia.json "bundled" or empty)
+ * 3. local path in adonia.json
+ * github:… is rejected until remote materialization lands.
+ */
+export async function resolveRegistry(options) {
+    if (options.registryFlag) {
+        const root = resolve(options.cwd, options.registryFlag);
+        if (!existsSync(root)) {
+            throw new Error(`Registry path not found: ${root}`);
+        }
+        return { root, index: loadRegistryIndex(root), source: 'flag' };
+    }
+    const hostReg = options.hostRegistry ?? 'bundled';
+    if (hostReg === 'bundled' || hostReg === '') {
+        return loadBundled();
+    }
+    if (hostReg.startsWith('github:')) {
+        throw new Error('GitHub registries (github:…) are not supported in adonia@0.1.x.\n' +
+            'Use "registry": "bundled", a local path in adonia.json, or\n' +
+            '--registry <dir>.');
+    }
+    // Treat other strings as local paths relative to cwd
+    const asPath = resolve(options.cwd, hostReg);
+    if (existsSync(asPath)) {
+        return { root: asPath, index: loadRegistryIndex(asPath), source: 'flag' };
+    }
+    console.warn(`Unknown registry "${hostReg}"; using bundled.`);
+    return loadBundled();
+}
+function loadBundled() {
+    const bundled = bundledRegistryPath();
+    if (!existsSync(bundled)) {
+        throw new Error(`Bundled registry missing at ${bundled}. Reinstall adonia or pass --registry <dir>.`);
+    }
+    return { root: bundled, index: loadRegistryIndex(bundled), source: 'bundled' };
+}
+export function loadManifest(registry, name) {
+    if (CORE_PACKAGES.includes(name)) {
+        return impliedCoreManifest(name);
+    }
+    const path = join(registry.root, name, 'module.json');
+    if (!existsSync(path)) {
+        throw new Error(`Unknown module "${name}". Run \`npx adonia list\` to see available modules.`);
+    }
+    return moduleManifestSchema.parse(JSON.parse(readFileSync(path, 'utf8')));
+}
+export function expandDependencies(registry, names, installed, overwrite) {
+    const ordered = [];
+    const visiting = new Set();
+    const visited = new Set();
+    function visit(name) {
+        if (visited.has(name))
+            return;
+        if (visiting.has(name)) {
+            throw new Error(`Cycle in registryDependencies involving "${name}"`);
+        }
+        visiting.add(name);
+        const manifest = loadManifest(registry, name);
+        for (const dep of manifest.registryDependencies) {
+            visit(dep);
+        }
+        if (name === 'api') {
+            for (const core of CORE_PACKAGES) {
+                visit(core);
+            }
+        }
+        visiting.delete(name);
+        visited.add(name);
+        if (!installed.has(name) || overwrite) {
+            if (!ordered.includes(name))
+                ordered.push(name);
+        }
+    }
+    for (const name of names) {
+        visit(name);
+    }
+    return ordered;
+}
+export function listAllModuleNames(registry) {
+    return [...registry.index.core, ...registry.index.modules];
+}
+export function moduleDir(registry, name) {
+    return join(registry.root, name);
+}
+export function relativeFromRegistry(registry, absPath) {
+    return relative(registry.root, absPath);
+}

package/build/registry/plan.d.ts

@@ -0,0 +1,53 @@
+import { type CopyOptions, type CopyResult } from '../copy.js';
+import type { HostModulesConfig, ModuleManifest } from '../schema.js';
+import type { Registry } from './index.js';
+export interface PlannedCopy {
+    src: string;
+    dest: string;
+    kind: 'file' | 'stub' | 'test';
+}
+/** App stub folders selected by CLI flags. Routes are never included in `--with-stubs`. */
+export type StubFolder = 'models' | 'migrations' | 'controllers' | 'validators' | 'routes' | 'providers' | 'start' | 'adapters';
+export interface StubSelect {
+    models: boolean;
+    migrations: boolean;
+    controllers: boolean;
+    validators: boolean;
+    routes: boolean;
+    /** Vine macros; selected with `--with-validators` or `--with-stubs`. */
+    providers: boolean;
+    /** Host start files (limiter); selected with `--with-routes` or `--with-stubs`. */
+    start: boolean;
+    /**
+     * Lucid / SDK host I/O. Selected with `--with-adapters`, `--with-stubs`,
+     * or `--with-controllers`.
+     */
+    adapters: boolean;
+}
+export declare const DEFAULT_ROUTES_DIR = "start/routes";
+export declare const DEFAULT_PROVIDERS_DIR = "providers";
+export declare const DEFAULT_START_DIR = "start";
+export declare const DEFAULT_ADAPTERS_DIR = "app/adapters";
+export declare function resolveStubSelect(flags: {
+    withStubs?: boolean;
+    withModels?: boolean;
+    withMigrations?: boolean;
+    withControllers?: boolean;
+    withValidators?: boolean;
+    withRoutes?: boolean;
+    withAdapters?: boolean;
+}): StubSelect | null;
+export declare function anyAppStubsSelected(select: StubSelect | null): boolean;
+export declare function planModuleFiles(registry: Registry, name: string, manifest: ModuleManifest, host: HostModulesConfig, cwd: string): PlannedCopy[];
+export declare function planStubs(registry: Registry, name: string, manifest: ModuleManifest, host: HostModulesConfig, cwd: string, warnings: string[], select: StubSelect): PlannedCopy[];
+export declare function manifestHasRouteStubs(manifest: ModuleManifest): boolean;
+export declare function hostRouteFile(cwd: string, moduleName: string): string;
+export declare function planTests(registry: Registry, name: string, host: HostModulesConfig, cwd: string): PlannedCopy[];
+export declare function executePlan(plans: PlannedCopy[], options: CopyOptions): {
+    results: {
+        plan: PlannedCopy;
+        result: CopyResult;
+    }[];
+    conflicts: PlannedCopy[];
+};
+export declare function describePlan(plan: PlannedCopy, cwd: string): string;

package/build/registry/plan.js

@@ -0,0 +1,159 @@
+import fg from 'fast-glob';
+import { existsSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { copyFileWithPolicy } from '../copy.js';
+import { moduleDir } from './index.js';
+const APP_STUB_FOLDERS = ['models', 'migrations', 'controllers', 'validators'];
+const STUB_FOLDER_TO_PATH_KEY = {
+    models: 'models',
+    migrations: 'migrations',
+    controllers: 'controllers',
+    validators: 'validators',
+};
+export const DEFAULT_ROUTES_DIR = 'start/routes';
+export const DEFAULT_PROVIDERS_DIR = 'providers';
+export const DEFAULT_START_DIR = 'start';
+export const DEFAULT_ADAPTERS_DIR = 'app/adapters';
+export function resolveStubSelect(flags) {
+    const withStubs = Boolean(flags.withStubs);
+    const withValidators = withStubs || Boolean(flags.withValidators);
+    const withControllers = withStubs || Boolean(flags.withControllers);
+    const withRoutes = Boolean(flags.withRoutes);
+    const select = {
+        models: withStubs || Boolean(flags.withModels),
+        migrations: withStubs || Boolean(flags.withMigrations),
+        controllers: withControllers,
+        validators: withValidators,
+        routes: withRoutes,
+        providers: withValidators,
+        start: withStubs || withRoutes,
+        adapters: withStubs || withControllers || Boolean(flags.withAdapters),
+    };
+    if (!APP_STUB_FOLDERS.some((f) => select[f]) &&
+        !select.routes &&
+        !select.providers &&
+        !select.start &&
+        !select.adapters) {
+        return null;
+    }
+    return select;
+}
+export function anyAppStubsSelected(select) {
+    if (!select)
+        return false;
+    return (APP_STUB_FOLDERS.some((f) => select[f]) ||
+        select.providers ||
+        select.start ||
+        select.adapters);
+}
+export function planModuleFiles(registry, name, manifest, host, cwd) {
+    const root = moduleDir(registry, name);
+    const destRoot = join(cwd, host.paths.modules, name);
+    const files = fg.sync(manifest.files.length ? manifest.files : ['**/*'], {
+        cwd: root,
+        onlyFiles: true,
+        dot: false,
+        ignore: ['stubs/**', 'tests/**', 'node_modules/**'],
+    });
+    return files.map((rel) => ({
+        src: join(root, rel),
+        dest: join(destRoot, rel),
+        kind: 'file',
+    }));
+}
+export function planStubs(registry, name, manifest, host, cwd, warnings, select) {
+    const root = moduleDir(registry, name);
+    const plans = [];
+    const stubGlobs = manifest.stubs.length ? manifest.stubs : [];
+    const files = fg.sync(stubGlobs, { cwd: root, onlyFiles: true });
+    for (const rel of files) {
+        // stubs/models/foo.ts
+        const without = rel.replace(/^stubs\//, '');
+        const slash = without.indexOf('/');
+        if (slash === -1) {
+            warnings.push(`Skipping stub with no folder: ${rel}`);
+            continue;
+        }
+        const folder = without.slice(0, slash);
+        const rest = without.slice(slash + 1);
+        if (!select[folder])
+            continue;
+        if (folder === 'routes') {
+            plans.push({
+                src: join(root, rel),
+                dest: join(cwd, DEFAULT_ROUTES_DIR, rest),
+                kind: 'stub',
+            });
+            continue;
+        }
+        if (folder === 'providers') {
+            plans.push({
+                src: join(root, rel),
+                dest: join(cwd, DEFAULT_PROVIDERS_DIR, rest),
+                kind: 'stub',
+            });
+            continue;
+        }
+        if (folder === 'start') {
+            plans.push({
+                src: join(root, rel),
+                dest: join(cwd, DEFAULT_START_DIR, rest),
+                kind: 'stub',
+            });
+            continue;
+        }
+        if (folder === 'adapters') {
+            plans.push({
+                src: join(root, rel),
+                dest: join(cwd, DEFAULT_ADAPTERS_DIR, rest),
+                kind: 'stub',
+            });
+            continue;
+        }
+        const pathKey = STUB_FOLDER_TO_PATH_KEY[folder];
+        if (!pathKey) {
+            warnings.push(`Unknown stub folder "${folder}" (${rel}); skipped`);
+            continue;
+        }
+        const destDir = host.paths[pathKey];
+        plans.push({
+            src: join(root, rel),
+            dest: join(cwd, destDir, rest),
+            kind: 'stub',
+        });
+    }
+    return plans;
+}
+export function manifestHasRouteStubs(manifest) {
+    return manifest.stubs.some((s) => /(^|\/)stubs\/routes(\/|$)/.test(s) || s.includes('stubs/routes'));
+}
+export function hostRouteFile(cwd, moduleName) {
+    return join(cwd, DEFAULT_ROUTES_DIR, `${moduleName}.ts`);
+}
+export function planTests(registry, name, host, cwd) {
+    const root = join(moduleDir(registry, name), 'tests');
+    if (!existsSync(root))
+        return [];
+    const files = fg.sync('**/*', { cwd: root, onlyFiles: true });
+    const destRoot = join(cwd, host.paths.modules, name, 'tests');
+    return files.map((rel) => ({
+        src: join(root, rel),
+        dest: join(destRoot, rel),
+        kind: 'test',
+    }));
+}
+export function executePlan(plans, options) {
+    const results = [];
+    const conflicts = [];
+    for (const plan of plans) {
+        const result = copyFileWithPolicy(plan.src, plan.dest, options);
+        results.push({ plan, result });
+        if (result === 'conflict' || result === 'would-conflict') {
+            conflicts.push(plan);
+        }
+    }
+    return { results, conflicts };
+}
+export function describePlan(plan, cwd) {
+    return `${plan.kind}: ${relative(cwd, plan.dest)}`;
+}

package/build/schema.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+export declare const moduleManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    stubs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    dependencies: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    registryDependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    peerModels: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    configKeys: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    events: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    hostFacingExceptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    hostTests: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    files: string[];
+    stubs: string[];
+    dependencies: Record<string, string>;
+    registryDependencies: string[];
+    peerModels: string[];
+    configKeys: string[];
+    env: string[];
+    events: string[];
+    hostFacingExceptions: string[];
+    hostTests: string[];
+}, {
+    name: string;
+    description?: string | undefined;
+    files?: string[] | undefined;
+    stubs?: string[] | undefined;
+    dependencies?: Record<string, string> | undefined;
+    registryDependencies?: string[] | undefined;
+    peerModels?: string[] | undefined;
+    configKeys?: string[] | undefined;
+    env?: string[] | undefined;
+    events?: string[] | undefined;
+    hostFacingExceptions?: string[] | undefined;
+    hostTests?: string[] | undefined;
+}>;
+export type ModuleManifest = z.infer<typeof moduleManifestSchema>;
+export declare const hostModulesSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    registry: z.ZodString;
+    ref: z.ZodString;
+    paths: z.ZodObject<{
+        modules: z.ZodString;
+        models: z.ZodString;
+        migrations: z.ZodString;
+        controllers: z.ZodString;
+        validators: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        modules: z.ZodString;
+        models: z.ZodString;
+        migrations: z.ZodString;
+        controllers: z.ZodString;
+        validators: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        modules: z.ZodString;
+        models: z.ZodString;
+        migrations: z.ZodString;
+        controllers: z.ZodString;
+        validators: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    aliases: z.ZodObject<{
+        modules: z.ZodString;
+        constants: z.ZodString;
+        models: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        modules: z.ZodString;
+        constants: z.ZodString;
+        models: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        modules: z.ZodString;
+        constants: z.ZodString;
+        models: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    installed: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    registry: string;
+    ref: string;
+    paths: {
+        modules: string;
+        models: string;
+        migrations: string;
+        controllers: string;
+        validators: string;
+    } & {
+        [k: string]: unknown;
+    };
+    aliases: {
+        modules: string;
+        models: string;
+        constants: string;
+    } & {
+        [k: string]: unknown;
+    };
+    installed: string[];
+    $schema?: string | undefined;
+}, {
+    registry: string;
+    ref: string;
+    paths: {
+        modules: string;
+        models: string;
+        migrations: string;
+        controllers: string;
+        validators: string;
+    } & {
+        [k: string]: unknown;
+    };
+    aliases: {
+        modules: string;
+        models: string;
+        constants: string;
+    } & {
+        [k: string]: unknown;
+    };
+    installed: string[];
+    $schema?: string | undefined;
+}>;
+export type HostModulesConfig = z.infer<typeof hostModulesSchema>;
+export declare const registryIndexSchema: z.ZodObject<{
+    core: z.ZodArray<z.ZodString, "many">;
+    modules: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    modules: string[];
+    core: string[];
+}, {
+    modules: string[];
+    core: string[];
+}>;
+export type RegistryIndex = z.infer<typeof registryIndexSchema>;
+export declare const CORE_PACKAGES: readonly ["types", "constants", "contracts"];
+export declare function impliedCoreManifest(name: (typeof CORE_PACKAGES)[number]): ModuleManifest;

package/build/schema.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+export const moduleManifestSchema = z.object({
+    name: z.string().min(1),
+    description: z.string().default(''),
+    files: z.array(z.string()).default([]),
+    stubs: z.array(z.string()).default([]),
+    dependencies: z.record(z.string()).default({}),
+    registryDependencies: z.array(z.string()).default([]),
+    peerModels: z.array(z.string()).default([]),
+    configKeys: z.array(z.string()).default([]),
+    env: z.array(z.string()).default([]),
+    events: z.array(z.string()).default([]),
+    hostFacingExceptions: z.array(z.string()).default([]),
+    hostTests: z.array(z.string()).default([]),
+});
+export const hostModulesSchema = z.object({
+    $schema: z.string().optional(),
+    registry: z.string().min(1),
+    ref: z.string().min(1),
+    paths: z
+        .object({
+        modules: z.string(),
+        models: z.string(),
+        migrations: z.string(),
+        controllers: z.string(),
+        validators: z.string(),
+    })
+        .passthrough(),
+    aliases: z
+        .object({
+        modules: z.string(),
+        constants: z.string(),
+        models: z.string(),
+    })
+        .passthrough(),
+    installed: z.array(z.string()),
+});
+export const registryIndexSchema = z.object({
+    core: z.array(z.string()),
+    modules: z.array(z.string()),
+});
+export const CORE_PACKAGES = ['types', 'constants', 'contracts'];
+export function impliedCoreManifest(name) {
+    return moduleManifestSchema.parse({
+        name,
+        description: `Shared ${name} package`,
+        files: ['**/*'],
+        stubs: [],
+        dependencies: {},
+        registryDependencies: [],
+        peerModels: [],
+        configKeys: [],
+        env: [],
+        events: [],
+        hostFacingExceptions: [],
+        hostTests: [],
+    });
+}

package/build/types.d.ts

@@ -0,0 +1,21 @@
+export interface SharedFlags {
+    cwd: string;
+    yes: boolean;
+    dryRun: boolean;
+    registry?: string;
+    overwrite: boolean;
+}
+/** Opt-in host scaffolding for `add` / `diff` / scaffold. */
+export interface ScaffoldFlags {
+    withModels?: boolean;
+    withMigrations?: boolean;
+    withControllers?: boolean;
+    withValidators?: boolean;
+    /** Lucid / SDK host I/O → `app/adapters/`. */
+    withAdapters?: boolean;
+    /** models + migrations + controllers + validators + adapters (not routes). */
+    withStubs?: boolean;
+    withRoutes?: boolean;
+    wireRoutes?: boolean;
+    withTests?: boolean;
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/build/wire.d.ts

@@ -0,0 +1,16 @@
+declare const REQUIRED_IMPORTS: Record<string, string>;
+declare const EMPTY_MODULES_CONFIG = "const modulesConfig: Record<string, { description: string; emits: string[] }> = {}\n\nexport default modulesConfig\n";
+export declare function printWireChecklist(): void;
+export declare function applyWire(cwd: string, dryRun?: boolean): string[];
+export { REQUIRED_IMPORTS, EMPTY_MODULES_CONFIG };
+/**
+ * Append a side-effect import of `start/routes/<module>.ts` into
+ * `start/routes.ts`. Idempotent. Does not create the module route file.
+ */
+export declare function wireModuleRoute(cwd: string, moduleName: string, dryRun?: boolean): {
+    ok: true;
+    actions: string[];
+} | {
+    ok: false;
+    error: string;
+};