adonia 0.1.0

package/build/commands/diff.js

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import { loadHostConfig } from '../host.js';
+import { loadManifest, resolveRegistry } from '../registry/index.js';
+import { planModuleFiles, planStubs, resolveStubSelect } from '../registry/plan.js';
+import { sha256 } from '../copy.js';
+export async function runDiff(name, flags) {
+    if (!name) {
+        console.error('Usage: adonia diff <name>');
+        process.exitCode = 1;
+        return;
+    }
+    let config;
+    try {
+        config = loadHostConfig(flags.cwd);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exitCode = 1;
+        return;
+    }
+    const registry = await resolveRegistry({
+        registryFlag: flags.registry,
+        hostRegistry: config.registry,
+        ref: config.ref,
+        cwd: flags.cwd,
+    });
+    const manifest = loadManifest(registry, name);
+    const warnings = [];
+    const stubSelect = resolveStubSelect(flags);
+    const plans = [
+        ...planModuleFiles(registry, name, manifest, config, flags.cwd),
+        ...(stubSelect
+            ? planStubs(registry, name, manifest, config, flags.cwd, warnings, stubSelect)
+            : []),
+    ];
+    let differed = false;
+    for (const plan of plans) {
+        if (!existsSync(plan.dest)) {
+            console.log(`--- missing: ${relative(flags.cwd, plan.dest)}`);
+            differed = true;
+            continue;
+        }
+        const a = readFileSync(plan.src);
+        const b = readFileSync(plan.dest);
+        if (sha256(a) === sha256(b))
+            continue;
+        differed = true;
+        console.log(unifiedDiff(relative(flags.cwd, plan.dest), a.toString('utf8'), b.toString('utf8')));
+    }
+    for (const w of warnings)
+        console.warn(w);
+    if (differed)
+        process.exitCode = 1;
+    else
+        console.log('No differences.');
+}
+function unifiedDiff(path, registry, host) {
+    const a = registry.split('\n');
+    const b = host.split('\n');
+    const lines = [`--- registry/${path}`, `+++ host/${path}`];
+    const max = Math.max(a.length, b.length);
+    for (let i = 0; i < max; i++) {
+        const left = a[i];
+        const right = b[i];
+        if (left === right)
+            continue;
+        if (left !== undefined)
+            lines.push(`-${left}`);
+        if (right !== undefined)
+            lines.push(`+${right}`);
+    }
+    return lines.join('\n');
+}

package/build/commands/init.d.ts

@@ -0,0 +1,6 @@
+import type { SharedFlags } from '../types.js';
+export declare function runInit(flags: SharedFlags & {
+    wire?: boolean;
+    skipCore?: boolean;
+    scaffold?: boolean;
+}): Promise<void>;

package/build/commands/init.js

@@ -0,0 +1,124 @@
+import { defaultHostConfig, isAdonisApp, loadHostConfig, writeHostConfig } from '../host.js';
+import { expandDependencies, resolveRegistry } from '../registry/index.js';
+import { CORE_PACKAGES } from '../schema.js';
+import { applyWire, printWireChecklist } from '../wire.js';
+import { installModules } from './add.js';
+export async function runInit(flags) {
+    const cwd = flags.cwd;
+    const check = isAdonisApp(cwd);
+    if (!check.ok) {
+        console.error(check.reason);
+        process.exitCode = 1;
+        return;
+    }
+    let wire = Boolean(flags.wire);
+    if (flags.scaffold && !wire) {
+        console.log('Scaffold implies --wire; enabling host wiring.');
+        wire = true;
+    }
+    let config = defaultHostConfig();
+    try {
+        config = loadHostConfig(cwd);
+        console.log('adonia.json already exists; keeping current config.');
+    }
+    catch {
+        writeHostConfig(cwd, config, flags.dryRun);
+        console.log(flags.dryRun ? 'Would write adonia.json' : 'Wrote adonia.json');
+    }
+    if (wire) {
+        const actions = applyWire(cwd, flags.dryRun);
+        if (actions.length) {
+            console.log(`${flags.dryRun ? 'Would wire' : 'Wired'}: ${actions.join(', ')}`);
+        }
+        else {
+            console.log('Host wiring already up to date.');
+        }
+    }
+    else {
+        printWireChecklist();
+    }
+    let registry;
+    try {
+        registry = await resolveRegistry({
+            registryFlag: flags.registry,
+            hostRegistry: config.registry,
+            ref: config.ref,
+            cwd,
+        });
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : err);
+        process.exitCode = 1;
+        return;
+    }
+    if (!flags.dryRun) {
+        try {
+            config = loadHostConfig(cwd);
+        }
+        catch {
+            /* keep in-memory default */
+        }
+    }
+    if (flags.skipCore) {
+        console.log('Skipping core install (--skip-core).');
+    }
+    else {
+        if (!flags.yes && !flags.dryRun) {
+            console.log('Install shared API core into ./modules? (yes)');
+        }
+        const coreNames = ['api', ...CORE_PACKAGES];
+        const toInstall = expandDependencies(registry, coreNames, new Set(config.installed), flags.overwrite);
+        if (!toInstall.length) {
+            console.log('Core already installed.');
+        }
+        else {
+            const result = await installModules({
+                names: toInstall,
+                flags: { ...flags, yes: true, withTests: false, suppressNextSteps: true },
+                config,
+                registry,
+            });
+            if (result.conflicts.length || result.wireErrors.length) {
+                process.exitCode = 1;
+            }
+            if (!flags.dryRun) {
+                try {
+                    config = loadHostConfig(cwd);
+                }
+                catch {
+                    /* keep */
+                }
+            }
+        }
+    }
+    if (!flags.scaffold)
+        return;
+    const featureNames = registry.index.modules;
+    if (!featureNames.length) {
+        console.log('No feature modules in registry to scaffold.');
+        return;
+    }
+    console.log(`Scaffolding feature modules: ${featureNames.join(', ')}`);
+    const ordered = expandDependencies(registry, featureNames, new Set(config.installed), flags.overwrite);
+    if (!ordered.length) {
+        console.log('Feature modules already installed. Use --overwrite to recopy stubs/routes.');
+        // Still attempt route wiring for already-installed modules when route files exist
+        return;
+    }
+    const result = await installModules({
+        names: ordered,
+        flags: {
+            ...flags,
+            yes: true,
+            withStubs: true,
+            withRoutes: true,
+            wireRoutes: true,
+            withTests: false,
+        },
+        config,
+        registry,
+    });
+    if (result.conflicts.length || result.wireErrors.length) {
+        process.exitCode = 1;
+    }
+}

package/build/commands/list.d.ts

@@ -0,0 +1,2 @@
+import type { SharedFlags } from '../types.js';
+export declare function runList(flags: SharedFlags): Promise<void>;

package/build/commands/list.js

@@ -0,0 +1,34 @@
+import { loadHostConfig } from '../host.js';
+import { listAllModuleNames, loadManifest, resolveRegistry } from '../registry/index.js';
+export async function runList(flags) {
+    let installed = new Set();
+    let hostRegistry;
+    let ref;
+    try {
+        const config = loadHostConfig(flags.cwd);
+        installed = new Set(config.installed);
+        hostRegistry = config.registry;
+        ref = config.ref;
+    }
+    catch {
+        console.log('(no adonia.json — showing registry only; run npx adonia init)');
+    }
+    const registry = await resolveRegistry({
+        registryFlag: flags.registry,
+        hostRegistry,
+        ref,
+        cwd: flags.cwd,
+    });
+    console.log(`Registry (${registry.source}): ${registry.root}\n`);
+    for (const name of listAllModuleNames(registry)) {
+        let description = '';
+        try {
+            description = loadManifest(registry, name).description;
+        }
+        catch {
+            description = '';
+        }
+        const mark = installed.has(name) ? 'installed' : 'available';
+        console.log(`  ${name.padEnd(16)} [${mark}]  ${description}`);
+    }
+}

package/build/config_merge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Insert or replace a single module key in config/modules.ts.
+ * Uses a lightweight text approach so we don't need a TS parser.
+ */
+export declare function mergeModulesConfig(path: string, name: string, description: string, events: string[], dryRun?: boolean): {
+    ok: true;
+} | {
+    ok: false;
+    snippet: string;
+};

package/build/config_merge.js

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+/**
+ * Insert or replace a single module key in config/modules.ts.
+ * Uses a lightweight text approach so we don't need a TS parser.
+ */
+export function mergeModulesConfig(path, name, description, events, dryRun = false) {
+    const entry = buildEntry(name, description, events);
+    if (!existsSync(path)) {
+        const content = `const modulesConfig: Record<string, { description: string; emits: string[] }> = {\n${entry}\n}\n\nexport default modulesConfig\n`;
+        if (!dryRun)
+            writeFileSync(path, content);
+        return { ok: true };
+    }
+    const original = readFileSync(path, 'utf8');
+    if (!/modulesConfig\s*[:=]/.test(original) && !/export\s+default/.test(original)) {
+        return { ok: false, snippet: entry };
+    }
+    // Replace existing key block or insert before closing brace of the object
+    const keyRe = new RegExp(`(^|\\n)\\s*${escapeRegExp(name)}\\s*:\\s*\\{[\\s\\S]*?\\n\\s*\\},?`, 'm');
+    let next;
+    if (keyRe.test(original)) {
+        next = original.replace(keyRe, `$1${entry}`);
+    }
+    else {
+        // Find the modulesConfig object closing
+        const openMatch = original.match(/((?:const|let|var)\s+modulesConfig[^=]*=\s*\{|modulesConfig\s*[:=]\s*\{)/);
+        if (!openMatch || openMatch.index === undefined) {
+            return { ok: false, snippet: entry };
+        }
+        const start = openMatch.index + openMatch[0].length;
+        const close = findMatchingBrace(original, start - 1);
+        if (close === -1)
+            return { ok: false, snippet: entry };
+        const before = original.slice(0, close);
+        const after = original.slice(close);
+        const needsComma = /[^\s,{]$/.test(before.trimEnd()) || /emits:\s*\[[^\]]*\]\s*$/.test(before);
+        const trimmed = before.replace(/\s*$/, '');
+        const comma = trimmed.endsWith(',') || trimmed.endsWith('{') ? '' : ',';
+        next = `${trimmed}${comma}\n${entry}\n${after}`;
+        void needsComma;
+    }
+    if (!dryRun)
+        writeFileSync(path, next);
+    return { ok: true };
+}
+function buildEntry(name, description, events) {
+    const emits = events.map((e) => `    '${e}',`).join('\n');
+    return `  ${name}: {
+    description: ${JSON.stringify(description)},
+    emits: [
+${emits}
+    ],
+  },`;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function findMatchingBrace(source, openIndex) {
+    let depth = 0;
+    for (let i = openIndex; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}

package/build/constants_merge.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Merge registry constant catalogs into the host copy without deleting host keys.
+ */
+export declare function mergeConstantsCatalogs(registryConstantsDir: string, hostConstantsDir: string, dryRun?: boolean): string[];

package/build/constants_merge.js

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CATALOG_FILES = ['exceptions.ts', 'responseCodes.ts'];
+/**
+ * Merge registry constant catalogs into the host copy without deleting host keys.
+ */
+export function mergeConstantsCatalogs(registryConstantsDir, hostConstantsDir, dryRun = false) {
+    const warnings = [];
+    for (const file of CATALOG_FILES) {
+        const src = join(registryConstantsDir, file);
+        const dest = join(hostConstantsDir, file);
+        if (!existsSync(src) || !existsSync(dest))
+            continue;
+        const result = mergeOneCatalog(src, dest, dryRun);
+        if (result)
+            warnings.push(result);
+    }
+    return warnings;
+}
+function mergeOneCatalog(src, dest, dryRun) {
+    const registryText = readFileSync(src, 'utf8');
+    const hostText = readFileSync(dest, 'utf8');
+    const regEntries = parseCatalogEntries(registryText);
+    const hostEntries = parseCatalogEntries(hostText);
+    if (!regEntries || !hostEntries) {
+        return `Could not parse ${dest} for constants merge; copy keys from the registry by hand.`;
+    }
+    let inserted = 0;
+    const conflicts = [];
+    const hostKeys = new Set(Object.keys(hostEntries.map));
+    let nextBody = hostEntries.body;
+    for (const [key, value] of Object.entries(regEntries.map)) {
+        if (!hostKeys.has(key)) {
+            // insert before closing brace of object
+            const insert = `  ${key}: ${value},\n`;
+            nextBody = nextBody.replace(/\n\}\s*$/, `\n${insert}}`);
+            inserted++;
+            continue;
+        }
+        if (normalizeEntry(hostEntries.map[key]) !== normalizeEntry(value)) {
+            conflicts.push(key);
+        }
+    }
+    if (inserted && !dryRun) {
+        writeFileSync(dest, hostText.slice(0, hostEntries.start) + nextBody + hostText.slice(hostEntries.end));
+    }
+    if (conflicts.length) {
+        return `Constants conflict in ${dest}: ${conflicts.join(', ')}`;
+    }
+    return null;
+}
+function normalizeEntry(s) {
+    return s.replace(/\s+/g, '');
+}
+function parseCatalogEntries(text) {
+    // Find first `= {` after export/const
+    const m = text.match(/=\s*\{/);
+    if (!m || m.index === undefined)
+        return null;
+    const open = m.index + m[0].length - 1;
+    let depth = 0;
+    let end = -1;
+    for (let i = open; i < text.length; i++) {
+        if (text[i] === '{')
+            depth++;
+        else if (text[i] === '}') {
+            depth--;
+            if (depth === 0) {
+                end = i + 1;
+                break;
+            }
+        }
+    }
+    if (end === -1)
+        return null;
+    const body = text.slice(open, end);
+    const map = {};
+    // Match KEY: { ... }, at top level
+    const entryRe = /(\w+)\s*:\s*(\{[^}]*\})/g;
+    let match;
+    while ((match = entryRe.exec(body))) {
+        map[match[1]] = match[2];
+    }
+    return { map, body, start: open, end };
+}

package/build/copy.d.ts

@@ -0,0 +1,8 @@
+export type CopyResult = 'copied' | 'skipped' | 'conflict' | 'would-copy' | 'would-skip' | 'would-conflict';
+export interface CopyOptions {
+    overwrite?: boolean;
+    dryRun?: boolean;
+}
+export declare function sha256(content: Buffer | string): string;
+export declare function copyFileWithPolicy(src: string, dest: string, options?: CopyOptions): CopyResult;
+export declare function ensureDir(path: string, dryRun?: boolean): void;

package/build/copy.js

@@ -0,0 +1,33 @@
+import { createHash } from 'node:crypto';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function sha256(content) {
+    return createHash('sha256').update(content).digest('hex');
+}
+export function copyFileWithPolicy(src, dest, options = {}) {
+    const { overwrite = false, dryRun = false } = options;
+    const srcBuf = readFileSync(src);
+    if (!existsSync(dest)) {
+        if (dryRun)
+            return 'would-copy';
+        mkdirSync(dirname(dest), { recursive: true });
+        copyFileSync(src, dest);
+        return 'copied';
+    }
+    const destBuf = readFileSync(dest);
+    if (sha256(srcBuf) === sha256(destBuf)) {
+        return dryRun ? 'would-skip' : 'skipped';
+    }
+    if (!overwrite) {
+        return dryRun ? 'would-conflict' : 'conflict';
+    }
+    if (dryRun)
+        return 'would-copy';
+    writeFileSync(dest, srcBuf);
+    return 'copied';
+}
+export function ensureDir(path, dryRun = false) {
+    if (dryRun)
+        return;
+    mkdirSync(path, { recursive: true });
+}

package/build/host.d.ts

@@ -0,0 +1,15 @@
+import { type HostModulesConfig } from './schema.js';
+export declare const ADONIA_JSON = "adonia.json";
+/** @deprecated Read-only fallback for one minor after rename. */
+export declare const LEGACY_MODULES_JSON = "modules.json";
+export declare function packageVersion(): string;
+export declare function isAdonisApp(cwd: string): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function loadHostConfig(cwd: string): HostModulesConfig;
+export declare function writeHostConfig(cwd: string, config: HostModulesConfig, dryRun?: boolean): void;
+export declare function defaultHostConfig(): HostModulesConfig;
+export declare function detectPackageManager(cwd: string): 'npm' | 'pnpm' | 'yarn';

package/build/host.js

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { hostModulesSchema } from './schema.js';
+export const ADONIA_JSON = 'adonia.json';
+/** @deprecated Read-only fallback for one minor after rename. */
+export const LEGACY_MODULES_JSON = 'modules.json';
+const require = createRequire(import.meta.url);
+export function packageVersion() {
+    try {
+        const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        try {
+            return require('../package.json').version;
+        }
+        catch {
+            return '0.0.0';
+        }
+    }
+}
+export function isAdonisApp(cwd) {
+    const adonisrc = join(cwd, 'adonisrc.ts');
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(adonisrc)) {
+        return { ok: false, reason: 'adonisrc.ts not found — not an Adonis app' };
+    }
+    if (!existsSync(pkgPath)) {
+        return { ok: false, reason: 'package.json not found' };
+    }
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (!deps['@adonisjs/core']) {
+        return { ok: false, reason: 'package.json does not depend on @adonisjs/core' };
+    }
+    return { ok: true };
+}
+function configPath(cwd) {
+    const primary = join(cwd, ADONIA_JSON);
+    if (existsSync(primary))
+        return primary;
+    const legacy = join(cwd, LEGACY_MODULES_JSON);
+    if (existsSync(legacy))
+        return legacy;
+    throw new Error(`Missing ${ADONIA_JSON}. Run \`npx adonia init\` first.`);
+}
+export function loadHostConfig(cwd) {
+    const path = configPath(cwd);
+    return hostModulesSchema.parse(JSON.parse(readFileSync(path, 'utf8')));
+}
+export function writeHostConfig(cwd, config, dryRun = false) {
+    if (dryRun)
+        return;
+    writeFileSync(join(cwd, ADONIA_JSON), `${JSON.stringify(config, null, 2)}\n`);
+}
+export function defaultHostConfig() {
+    return hostModulesSchema.parse({
+        $schema: './node_modules/adonia/schema/adonia.schema.json',
+        registry: 'bundled',
+        ref: packageVersion(),
+        paths: {
+            modules: 'modules',
+            models: 'app/models',
+            migrations: 'database/migrations',
+            controllers: 'app/controllers',
+            validators: 'app/validators',
+        },
+        aliases: {
+            modules: '#modules',
+            constants: '#constants',
+            models: '#models',
+        },
+        installed: [],
+    });
+}
+export function detectPackageManager(cwd) {
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}

package/build/registry/index.d.ts

@@ -0,0 +1,26 @@
+import { type ModuleManifest, type RegistryIndex } from '../schema.js';
+export interface Registry {
+    root: string;
+    index: RegistryIndex;
+    source: 'flag' | 'bundled';
+}
+export declare function bundledRegistryPath(): string;
+export declare function loadRegistryIndex(root: string): RegistryIndex;
+/**
+ * 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 declare function resolveRegistry(options: {
+    registryFlag?: string;
+    hostRegistry?: string;
+    ref?: string;
+    cwd: string;
+}): Promise<Registry>;
+export declare function loadManifest(registry: Registry, name: string): ModuleManifest;
+export declare function expandDependencies(registry: Registry, names: string[], installed: Set<string>, overwrite: boolean): string[];
+export declare function listAllModuleNames(registry: Registry): string[];
+export declare function moduleDir(registry: Registry, name: string): string;
+export declare function relativeFromRegistry(registry: Registry, absPath: string): string;