primo-cli 0.1.3 → 0.1.5

package/dist/index.js

@@ -1,21 +1,41 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import chalk from 'chalk';
+import { init_workspace } from './commands/init.js';
 import { new_site } from './commands/new.js';
 import { pull_site } from './commands/pull.js';
 import { push_site } from './commands/push.js';
+import { pull_library } from './commands/pull-library.js';
+import { push_library } from './commands/push-library.js';
 import { dev_server } from './commands/dev.js';
 import { login } from './commands/login.js';
 import { validate_site } from './commands/validate.js';
-import { publish } from './commands/publish.js';
+import { deploy } from './commands/deploy.js';
 import { build_site } from './commands/build.js';
 const program = new Command();
 program
     .name('primo')
     .description('Build sites visually, edit them anywhere')
     .version('0.1.3');
+// Top-level help: prepend a Deploy-vs-build-vs-push decision tree so first-time
+// users can pick a command without reading every description. Use 'before' so
+// it only renders for the root program, not subcommand help.
+program.addHelpText('before', `
+${chalk.bold('Local development')}
+  ${chalk.cyan('primo dev')}      Run the local CMS on this workspace
+
+${chalk.bold('Going live — pick one')}
+  Want others to edit content? .................. ${chalk.cyan('primo deploy')}
+  Just hosting a static blog? ................... ${chalk.cyan('primo build')}
+  Already have a hosted Primo server? ........... ${chalk.cyan('primo push')}
+`);
+program
+    .command('init [name]')
+    .description('Initialize a new Primo workspace (server) in a new folder or the current directory')
+    .action((name) => init_workspace({ name }));
 program
     .command('new [name]')
-    .description('Create a new site and start local CMS')
+    .description('Create a new site in the current workspace and start local CMS')
     .option('-t, --template <template>', 'Starter template')
     .option('--skip-dev', 'Create files only, don\'t start CMS')
     .action((name, options) => new_site({ name, ...options }));
@@ -24,37 +44,82 @@ program
     .description('Start local CMS')
     .option('-d, --dir <dir>', 'Site directory', '.')
     .option('-p, --port <port>', 'Port', '3000')
+    .option('-f, --force', 'Kill existing processes on the port')
+    .option('--author <mode>', 'Who is authoring this session: "files" (push only; CMS UI is read-only — default), "cms" (CMS edits write to files; file edits revert), "both" (bidirectional; CMS edits often lost on conflict — beta)', 'files')
     .action(dev_server);
 program
-    .command('publish')
-    .description('Deploy site with CMS')
-    .option('-d, --dir <dir>', 'Site directory', '.')
-    .option('-p, --provider <provider>', 'Provider (railway, fly)')
-    .action(publish);
+    .command('deploy')
+    .description('Deploy this workspace (all sites) with editable CMS (Railway, Fly)')
+    .option('-p, --provider <provider>', 'Provider: railway | fly')
+    .option('--dry-run', 'Show what would be deployed without doing anything')
+    .addHelpText('after', `
+${chalk.bold('Supported providers')}
+  railway   Railway (railway.com) — requires the Railway CLI and a logged-in account
+  fly       Fly.io — requires the flyctl CLI and a logged-in account
+
+For other hosts (Netlify, Vercel, Cloudflare, GitHub Pages), use ${chalk.cyan('primo build')}
+on a single site and deploy the output folder with that host's CLI.
+
+${chalk.bold('Workspace layout uploaded as one unit')}
+  server.yaml
+  library/      (if present)
+  sites/        (every site under this directory)
+
+${chalk.bold('See also')}
+  primo build   Export a single site as static files
+  primo push    Sync local changes to an existing hosted Primo server
+`)
+    .action(deploy);
 program
-    .command('push')
-    .description('Push local files to hosted CMS')
+    .command('push [server]')
+    .description('Sync local changes to an existing hosted Primo server')
     .option('-s, --server <url>', 'Server URL')
     .option('--site <id>', 'Site ID')
+    .option('--only <slug>', 'Push only the named site folder under sites/ (skips library)')
     .option('-d, --dir <dir>', 'Directory', '.')
     .option('-t, --token <token>', 'Auth token')
     .option('--preview', 'Preview only')
-    .action(push_site);
+    .option('--dry-run', 'Show what would be pushed without sending requests')
+    .addHelpText('after', `
+${chalk.bold('Requires an existing hosted Primo server.')}
+Run ${chalk.cyan('primo deploy')} first to create one, then ${chalk.cyan('primo login -s <server-url>')}
+to authenticate this machine before pushing.
+
+${chalk.bold('See also')}
+  primo deploy  Stand up a new hosted Primo server
+  primo login   Authenticate with a hosted Primo server
+`)
+    .action((server, options) => push_site({ ...options, server: server || options.server }));
 program
-    .command('pull')
-    .description('Pull from hosted CMS to local files')
+    .command('pull [server]')
+    .description('Pull entire server (all sites + library) to local files')
+    .option('-s, --server <url>', 'Server URL (auto-detects local)')
+    .option('-o, --output <dir>', 'Output directory (defaults to ./<server-hostname>)', '.')
+    .option('-t, --token <token>', 'Auth token')
+    .action((server, options) => pull_site({ ...options, server: server || options.server }));
+const library = program
+    .command('library')
+    .description('Manage shared block library');
+library
+    .command('pull [server]')
+    .description('Pull shared library to local files')
     .option('-s, --server <url>', 'Server URL (auto-detects local)')
-    .option('--site <id>', 'Site ID (interactive if not provided)')
     .option('-o, --output <dir>', 'Output directory', '.')
     .option('-t, --token <token>', 'Auth token')
-    .action(pull_site);
+    .action((server, options) => pull_library({ ...options, server: server || options.server }));
+library
+    .command('push [server]')
+    .description('Push local shared library to hosted CMS')
+    .option('-s, --server <url>', 'Server URL')
+    .option('-d, --dir <dir>', 'Workspace directory', '.')
+    .option('-t, --token <token>', 'Auth token')
+    .action((server, options) => push_library({ ...options, server: server || options.server }));
 program
-    .command('login')
+    .command('login [server]')
     .description('Login to hosted CMS')
-    .argument('<server>', 'Server URL')
+    .option('-s, --server <url>', 'Server URL (defaults to `server:` in server.yaml)')
     .option('-e, --email <email>', 'Email')
-    .option('-p, --password <password>', 'Password')
-    .action((server, options) => login({ server, ...options }));
+    .action((server, options) => login({ ...options, server: server || options.server }));
 program
     .command('validate')
     .description('Validate site structure')
@@ -63,8 +128,33 @@ program
     .action(validate_site);
 program
     .command('build')
-    .description('Build static site')
+    .description('Export a single site as static files for any host (Netlify, Vercel, etc.)')
     .option('-d, --dir <dir>', 'Site directory', '.')
-    .option('-o, --output <dir>', 'Output directory', 'dist')
+    .option('-o, --output <dir>', 'Output directory', '_site')
+    .addHelpText('after', `
+${chalk.bold('See also')}
+  primo deploy  Want collaborators to edit content from a CMS UI? Use deploy instead —
+                it ships the workspace with an editable CMS to Railway or Fly.
+`)
     .action(build_site);
+// Custom unknown-command handler. commander's default suggestion engine is
+// based on Levenshtein distance and won't reach across renames like
+// publish→deploy, so handle the common renamed/unknown cases explicitly.
+program.on('command:*', (operands) => {
+    const cmd = operands[0];
+    console.error('');
+    console.error(chalk.red(`Unknown command: ${cmd}`));
+    console.error('');
+    if (cmd === 'publish') {
+        console.error(`  ${chalk.cyan('primo publish')} has been replaced by ${chalk.cyan('primo deploy')}.`);
+        console.error(`  ${chalk.dim('It now deploys your whole workspace (all sites + library) as one unit.')}`);
+        console.error('');
+        console.error(`  Run: ${chalk.cyan('primo deploy --help')}`);
+    }
+    else {
+        console.error(`  Run ${chalk.cyan('primo --help')} to see available commands.`);
+    }
+    console.error('');
+    process.exit(1);
+});
 program.parse();

package/dist/utils/binary.js

@@ -10,7 +10,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PRIMO_HOME = path.join(os.homedir(), '.primo');
 const BIN_DIR = path.join(PRIMO_HOME, 'bin');
 const DATA_DIR = path.join(PRIMO_HOME, 'data');
-const VERSION = '0.1.0'; // TODO: fetch latest from GitHub
+const VERSION = '3.1.0'; // matches palacms releases
 // Path to locally built binary (for development)
 // The binary is at palacms/palacms (inside the palacms repo directory)
 const LOCAL_BINARY = path.resolve(__dirname, '..', '..', '..', 'palacms', 'palacms');

package/dist/utils/format.d.ts

@@ -0,0 +1,12 @@
+export interface FormatOptions {
+    enabled: boolean;
+    use_tabs: boolean;
+    tab_width: number;
+    print_width: number;
+    semi: boolean;
+    single_quote: boolean;
+    trailing_comma: 'none' | 'es5' | 'all';
+}
+export declare const DEFAULT_FORMAT_OPTIONS: FormatOptions;
+export declare function should_format(file_path: string): boolean;
+export declare function format_file_contents(file_path: string, contents: string, workspace_dir: string, options: FormatOptions): Promise<string>;

package/dist/utils/format.js

@@ -0,0 +1,98 @@
+import path from 'path';
+import { createRequire } from 'module';
+import chalk from 'chalk';
+export const DEFAULT_FORMAT_OPTIONS = {
+    enabled: true,
+    use_tabs: true,
+    tab_width: 2,
+    print_width: 100,
+    semi: false,
+    single_quote: true,
+    trailing_comma: 'none'
+};
+const FORMATTABLE_EXTENSIONS = new Set(['.yaml', '.yml', '.svelte', '.ts', '.js', '.json']);
+let prettier_module = undefined;
+let svelte_plugin_module = undefined;
+let warned_no_prettier = false;
+function resolve_prettier(workspace_dir) {
+    if (prettier_module !== undefined)
+        return prettier_module;
+    const require_from_workspace = createRequire(path.join(workspace_dir, 'package.json'));
+    try {
+        prettier_module = require_from_workspace('prettier');
+        return prettier_module;
+    }
+    catch {
+        // Not installed in workspace — try CLI's own deps as a fallback.
+        try {
+            prettier_module = createRequire(import.meta.url)('prettier');
+            return prettier_module;
+        }
+        catch {
+            prettier_module = null;
+            return null;
+        }
+    }
+}
+function resolve_svelte_plugin(workspace_dir) {
+    if (svelte_plugin_module !== undefined)
+        return svelte_plugin_module;
+    const require_from_workspace = createRequire(path.join(workspace_dir, 'package.json'));
+    try {
+        svelte_plugin_module = require_from_workspace('prettier-plugin-svelte');
+        return svelte_plugin_module;
+    }
+    catch {
+        try {
+            svelte_plugin_module = createRequire(import.meta.url)('prettier-plugin-svelte');
+            return svelte_plugin_module;
+        }
+        catch {
+            svelte_plugin_module = null;
+            return null;
+        }
+    }
+}
+export function should_format(file_path) {
+    return FORMATTABLE_EXTENSIONS.has(path.extname(file_path).toLowerCase());
+}
+export async function format_file_contents(file_path, contents, workspace_dir, options) {
+    if (!options.enabled)
+        return contents;
+    if (!should_format(file_path))
+        return contents;
+    const prettier = resolve_prettier(workspace_dir);
+    if (!prettier) {
+        if (!warned_no_prettier) {
+            warned_no_prettier = true;
+            console.log(chalk.dim(`  formatter: prettier not found in workspace; install \`prettier\` (and \`prettier-plugin-svelte\` for .svelte) or set format.enabled=false in server.yaml to silence`));
+        }
+        return contents;
+    }
+    const ext = path.extname(file_path).toLowerCase();
+    const plugins = [];
+    if (ext === '.svelte') {
+        const svelte_plugin = resolve_svelte_plugin(workspace_dir);
+        if (svelte_plugin)
+            plugins.push(svelte_plugin);
+    }
+    const prettier_options = {
+        filepath: file_path,
+        useTabs: options.use_tabs,
+        tabWidth: options.tab_width,
+        printWidth: options.print_width,
+        semi: options.semi,
+        singleQuote: options.single_quote,
+        trailingComma: options.trailing_comma,
+        plugins
+    };
+    try {
+        const formatted = await prettier.format(contents, prettier_options);
+        return formatted;
+    }
+    catch (err) {
+        // Don't break the import flow on a formatter error — just skip and warn.
+        console.log(chalk.yellow(`  formatter: skipping ${path.basename(file_path)} (${err.message})`));
+        return contents;
+    }
+}

package/dist/utils/head-svelte.d.ts

@@ -0,0 +1,2 @@
+export declare function validate_head_svelte_content(source: string, file_path?: string): void;
+export declare function get_head_svelte_validation_error(source: string, file_path?: string): string | null;

package/dist/utils/head-svelte.js

@@ -0,0 +1,53 @@
+import { parse } from 'svelte/compiler';
+export function validate_head_svelte_content(source, file_path = 'site/head.svelte') {
+    const error = get_head_svelte_validation_error(source, file_path);
+    if (error) {
+        throw new Error(error);
+    }
+}
+export function get_head_svelte_validation_error(source, file_path = 'site/head.svelte') {
+    const duplicate_head = find_duplicate_head(source);
+    if (duplicate_head) {
+        return format_violation(file_path, duplicate_head);
+    }
+    try {
+        parse(`<svelte:head>${source}</svelte:head>`, { modern: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `${file_path} has invalid Svelte syntax: ${message}`;
+    }
+    return null;
+}
+function find_duplicate_head(source) {
+    const source_without_comments = source.replace(/<!--[\s\S]*?-->/g, (comment) => ' '.repeat(comment.length));
+    const match = /<\s*svelte:head\b/i.exec(source_without_comments);
+    if (!match) {
+        return null;
+    }
+    return {
+        tag: '<svelte:head>',
+        message: 'remove the wrapper.',
+        ...offset_to_line_column(source, match.index)
+    };
+}
+function format_violation(file_path, violation) {
+    const location = violation.line
+        ? `${file_path}:${violation.line}:${violation.column || 1}`
+        : file_path;
+    return `${location} contains ${violation.tag}. ${file_path} is injected into <svelte:head>; ${violation.message} Keep only head children such as <title>, <meta>, <link>, <script>, and <style>.`;
+}
+function offset_to_line_column(source, offset) {
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < offset; i++) {
+        if (source[i] === '\n') {
+            line += 1;
+            column = 1;
+        }
+        else {
+            column += 1;
+        }
+    }
+    return { line, column };
+}

package/dist/utils/server-config.d.ts

@@ -0,0 +1,19 @@
+import { type FormatOptions } from './format.js';
+export interface SiteGroupConfig {
+    id: string;
+    name: string;
+    index?: number;
+}
+export interface ServerConfig {
+    port?: number;
+    site_groups?: SiteGroupConfig[];
+    format?: Partial<FormatOptions>;
+    server?: string;
+}
+export declare const SERVER_CONFIG_FILE = "server.yaml";
+export declare function get_server_config_path(base_dir: string): string;
+export declare function format_group_name(group_id: string): string;
+export declare function normalize_server_config(config: ServerConfig): ServerConfig;
+export declare function resolve_format_options(config: ServerConfig): FormatOptions;
+export declare function read_server_config(base_dir: string): Promise<ServerConfig>;
+export declare function write_server_config(base_dir: string, config: ServerConfig): Promise<void>;

package/dist/utils/server-config.js

@@ -0,0 +1,49 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { dump as dump_yaml, load as load_yaml } from 'js-yaml';
+import { DEFAULT_FORMAT_OPTIONS } from './format.js';
+export const SERVER_CONFIG_FILE = 'server.yaml';
+export function get_server_config_path(base_dir) {
+    return path.join(base_dir, SERVER_CONFIG_FILE);
+}
+export function format_group_name(group_id) {
+    if (!group_id.trim())
+        return 'Default';
+    return group_id
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+export function normalize_server_config(config) {
+    const site_groups = Array.isArray(config.site_groups)
+        ? config.site_groups.reduce((groups, group, index) => {
+            if (!group || typeof group.id !== 'string' || !group.id.trim())
+                return groups;
+            groups.push({
+                id: group.id,
+                name: typeof group.name === 'string' && group.name.trim() ? group.name : format_group_name(group.id),
+                index: Number.isInteger(group.index) ? group.index : index
+            });
+            return groups;
+        }, [])
+        : undefined;
+    return {
+        port: config.port,
+        site_groups,
+        format: config.format,
+        server: typeof config.server === 'string' && config.server.trim()
+            ? config.server.trim().replace(/\/+$/, '')
+            : undefined
+    };
+}
+export function resolve_format_options(config) {
+    return { ...DEFAULT_FORMAT_OPTIONS, ...(config.format ?? {}) };
+}
+export async function read_server_config(base_dir) {
+    const config_data = await fs.readFile(get_server_config_path(base_dir), 'utf-8');
+    return normalize_server_config(load_yaml(config_data));
+}
+export async function write_server_config(base_dir, config) {
+    await fs.writeFile(get_server_config_path(base_dir), dump_yaml(normalize_server_config(config), { lineWidth: -1, noRefs: true }));
+}

package/dist/utils/site-config.d.ts

@@ -0,0 +1,11 @@
+export interface SiteConfig {
+    name: string;
+    site_id: string;
+    host?: string;
+    server?: string;
+    group?: string;
+}
+export declare const SITE_CONFIG_FILE = "site.yaml";
+export declare function get_site_config_path(site_dir: string): string;
+export declare function read_site_config(site_dir: string): Promise<SiteConfig>;
+export declare function write_site_config(site_dir: string, config: SiteConfig): Promise<void>;

package/dist/utils/site-config.js

@@ -0,0 +1,14 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { dump as dump_yaml, load as load_yaml } from 'js-yaml';
+export const SITE_CONFIG_FILE = 'site.yaml';
+export function get_site_config_path(site_dir) {
+    return path.join(site_dir, SITE_CONFIG_FILE);
+}
+export async function read_site_config(site_dir) {
+    const config_data = await fs.readFile(get_site_config_path(site_dir), 'utf-8');
+    return load_yaml(config_data);
+}
+export async function write_site_config(site_dir, config) {
+    await fs.writeFile(get_site_config_path(site_dir), dump_yaml(config, { lineWidth: -1, noRefs: true }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "primo-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Local development CLI for Primo",
   "type": "module",
   "bin": {
@@ -14,11 +14,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/palacms/cli.git"
+    "url": "git+https://github.com/primocms/primo-cli.git"
   },
   "homepage": "https://primo.page",
   "bugs": {
-    "url": "https://github.com/palacms/cli/issues"
+    "url": "https://github.com/primocms/primo-cli/issues"
   },
   "keywords": [
     "primo",
@@ -34,10 +34,14 @@
     "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "commander": "^12.1.0",
+    "esbuild": "^0.27.4",
     "extract-zip": "^2.0.1",
     "inquirer": "^13.3.0",
     "js-yaml": "^4.1.0",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "prettier": "^3.0.0",
+    "prettier-plugin-svelte": "^3.0.0",
+    "svelte": "^5.55.0"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.2",

package/dist/commands/export.d.ts

@@ -1,8 +0,0 @@
-interface ExportOptions {
-    server: string;
-    site: string;
-    output: string;
-    token?: string;
-}
-export declare function export_site(options: ExportOptions): Promise<void>;
-export {};

package/dist/commands/export.js

@@ -1,163 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-import extract from 'extract-zip';
-import { get_auth_token } from '../utils/auth.js';
-export async function export_site(options) {
-    const spinner = ora('Connecting to server...').start();
-    try {
-        // Get auth token
-        const token = options.token || await get_auth_token(options.server);
-        if (!token) {
-            spinner.fail('Authentication required. Use --token or run `pala login` first.');
-            process.exit(1);
-        }
-        // Create output directory
-        const output_dir = path.resolve(options.output);
-        await fs.mkdir(output_dir, { recursive: true });
-        // Fetch the export
-        spinner.text = 'Exporting site...';
-        const response = await fetch(`${options.server}/api/palacms/export/${options.site}`, {
-            headers: {
-                'Authorization': `Bearer ${token}`
-            }
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            spinner.fail(`Export failed: ${error}`);
-            process.exit(1);
-        }
-        // Save ZIP temporarily
-        const zip_data = await response.arrayBuffer();
-        const temp_zip = path.join(output_dir, '.pala-export.zip');
-        await fs.writeFile(temp_zip, Buffer.from(zip_data));
-        // Extract ZIP
-        spinner.text = 'Extracting files...';
-        await extract(temp_zip, { dir: output_dir });
-        // Clean up temp ZIP
-        await fs.unlink(temp_zip);
-        // Copy JSON schemas
-        spinner.text = 'Adding JSON schemas...';
-        await copy_schemas(output_dir);
-        // Add $schema references
-        await add_schema_references(output_dir);
-        spinner.succeed(`Site exported to ${chalk.cyan(output_dir)}`);
-        // Show summary
-        const files = await count_files(output_dir);
-        console.log('');
-        console.log(chalk.dim('  Files exported:'));
-        console.log(chalk.dim(`    blocks/     ${files.blocks} blocks`));
-        console.log(chalk.dim(`    page-types/ ${files.page_types} page types`));
-        console.log(chalk.dim(`    pages/      ${files.pages} pages`));
-        console.log('');
-        console.log(chalk.green('  Ready for local development!'));
-        console.log(chalk.dim('  Run `pala dev` to start the local server'));
-    }
-    catch (error) {
-        spinner.fail(`Export failed: ${error instanceof Error ? error.message : error}`);
-        process.exit(1);
-    }
-}
-async function count_files(dir) {
-    const counts = { blocks: 0, page_types: 0, pages: 0 };
-    try {
-        const blocks_dir = path.join(dir, 'blocks');
-        const entries = await fs.readdir(blocks_dir, { withFileTypes: true });
-        counts.blocks = entries.filter(e => e.isDirectory()).length;
-    }
-    catch { }
-    try {
-        const pt_dir = path.join(dir, 'page-types');
-        const entries = await fs.readdir(pt_dir, { withFileTypes: true });
-        counts.page_types = entries.filter(e => e.isDirectory()).length;
-    }
-    catch { }
-    try {
-        const pages_dir = path.join(dir, 'pages');
-        counts.pages = await count_json_files(pages_dir);
-    }
-    catch { }
-    return counts;
-}
-async function count_json_files(dir) {
-    let count = 0;
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            count += await count_json_files(path.join(dir, entry.name));
-        }
-        else if (entry.name.endsWith('.json')) {
-            count++;
-        }
-    }
-    return count;
-}
-async function copy_schemas(output_dir) {
-    // Get path to schemas directory relative to compiled dist file
-    const current_file = new URL(import.meta.url).pathname;
-    const dist_dir = path.dirname(path.dirname(current_file)); // dist/
-    const project_root = path.dirname(dist_dir); // project root
-    const schemas_src = path.join(project_root, 'schemas');
-    const schemas_dest = path.join(output_dir, '.schemas');
-    await fs.mkdir(schemas_dest, { recursive: true });
-    const schema_files = await fs.readdir(schemas_src);
-    for (const file of schema_files) {
-        if (file.endsWith('.json')) {
-            await fs.copyFile(path.join(schemas_src, file), path.join(schemas_dest, file));
-        }
-    }
-}
-async function add_schema_references(output_dir) {
-    // Add $schema to block fields.json
-    const blocks_dir = path.join(output_dir, 'blocks');
-    try {
-        const blocks = await fs.readdir(blocks_dir, { withFileTypes: true });
-        for (const block of blocks) {
-            if (block.isDirectory()) {
-                const fields_path = path.join(blocks_dir, block.name, 'fields.json');
-                try {
-                    const fields = JSON.parse(await fs.readFile(fields_path, 'utf-8'));
-                    // Create new object with $schema first
-                    const with_schema = {
-                        $schema: '../../.schemas/fields.schema.json',
-                        ...fields
-                    };
-                    await fs.writeFile(fields_path, JSON.stringify(with_schema, null, 2) + '\n');
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-    // Add $schema to page-type config.json
-    const page_types_dir = path.join(output_dir, 'page-types');
-    try {
-        const page_types = await fs.readdir(page_types_dir, { withFileTypes: true });
-        for (const page_type of page_types) {
-            if (page_type.isDirectory()) {
-                const config_path = path.join(page_types_dir, page_type.name, 'config.json');
-                try {
-                    const config = JSON.parse(await fs.readFile(config_path, 'utf-8'));
-                    // Create new object with $schema first
-                    const with_schema = {
-                        $schema: '../../.schemas/page-type-config.schema.json',
-                        ...config
-                    };
-                    await fs.writeFile(config_path, JSON.stringify(with_schema, null, 2) + '\n');
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-    // Add $schema to site fields.json
-    const site_fields_path = path.join(output_dir, 'site/fields.json');
-    try {
-        const site_fields = JSON.parse(await fs.readFile(site_fields_path, 'utf-8'));
-        // Site fields is an array, so we need to add $schema differently
-        // Since JSON Schema doesn't support $schema in arrays, we'll skip this for now
-        // IDEs can still use the schema if users manually add it via settings
-    }
-    catch { }
-}