fix(scaffold): make blank/init outputs pass objectstack validate

Both @objectstack/cli init and create-objectstack's bundled `blank`
template produced projects that failed validation: missing manifest
namespace and object names violating the `${namespace}_${shortName}` rule.

- packages/cli: sanitizeNamespace + __name__ path substitution, threaded
  (name, namespace) through template fns, post-scaffold bundleRequire
  self-test; round-trip render tests
- packages/create-objectstack: template files declare namespace + use
  `blank_note`; rewriteProjectIdentity now also reads the template's
  original namespace and swaps `name: '${templateNs}_*'` → user namespace
  across src/**/*.ts; version pulled from package.json

Bumps @objectstack/cli and create-objectstack to 6.5.2.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: os-zhuang

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/cli",
-  "version": "6.5.1",
+  "version": "6.5.2",
   "description": "Command Line Interface for ObjectStack Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

packages/cli/src/commands/init.ts

@@ -37,13 +37,37 @@ function pkgVersion(): string {
   return `^${getCliVersion()}`;
 }
 
+/**
+ * Convert an npm package name into a valid ObjectStack namespace identifier.
+ *
+ * Namespace rules (from `ManifestSchema` in `@objectstack/spec`):
+ *   - 2-20 chars, `^[a-z][a-z0-9_]{1,19}$`
+ *   - Reserved: `base`, `system`, `sys`
+ *
+ * npm names allow hyphens/dots/scopes (e.g. `@acme/my-app`); identifiers don't.
+ * We strip the scope, replace separators with `_`, lowercase, prefix a leading
+ * digit, truncate to 20, and pad short names so the result always satisfies
+ * the regex. Reserved names get a `_app` suffix.
+ */
+export function sanitizeNamespace(name: string): string {
+  let s = name.replace(/^@[^/]+\//, '');           // drop npm scope
+  s = s.toLowerCase().replace(/[^a-z0-9]+/g, '_'); // separators → _
+  s = s.replace(/^_+|_+$/g, '');                   // trim underscores
+  if (!s) s = 'app';
+  if (/^[0-9]/.test(s)) s = 'a' + s;               // must start with a letter
+  if (s.length < 2) s = (s + '_app').slice(0, 20);
+  if (s.length > 20) s = s.slice(0, 20).replace(/_+$/, '');
+  if (['base', 'system', 'sys'].includes(s)) s = (s + '_app').slice(0, 20);
+  return s;
+}
+
 export const TEMPLATES: Record<string, {
   description: string;
   dependencies: Record<string, string>;
   devDependencies: Record<string, string>;
   scripts: Record<string, string>;
-  configContent: (name: string) => string;
-  srcFiles: Record<string, (name: string) => string>;
+  configContent: (name: string, namespace: string) => string;
+  srcFiles: Record<string, (name: string, namespace: string) => string>;
 }> = {
   app: {
     description: 'Full application with objects, views, and actions',
@@ -69,13 +93,13 @@ export const TEMPLATES: Record<string, {
       validate: 'objectstack validate',
       typecheck: 'tsc --noEmit',
     },
-    configContent: (name: string) => `import { defineStack } from '@objectstack/spec';
+    configContent: (name: string, namespace: string) => `import { defineStack } from '@objectstack/spec';
 import * as objects from './src/objects';
 
 export default defineStack({
   manifest: {
-    id: 'com.example.${name}',
-    namespace: '${name}',
+    id: 'com.example.${namespace}',
+    namespace: '${namespace}',
     version: '0.1.0',
     type: 'app',
     name: '${toTitleCase(name)}',
@@ -86,13 +110,13 @@ export default defineStack({
 });
 `,
     srcFiles: {
-      'src/objects/index.ts': (name) => `export { default as ${toCamelCase(name)} } from './${name}';
+      'src/objects/index.ts': (_name, namespace) => `export { default as ${toCamelCase(namespace)}Item } from './${namespace}_item';
 `,
-      'src/objects/__name__.ts': (name) => `import * as Data from '@objectstack/spec/data';
+      'src/objects/__name___item.ts': (_name, namespace) => `import * as Data from '@objectstack/spec/data';
 
-const ${toCamelCase(name)}: Data.Object = {
-  name: '${name}',
-  label: '${toTitleCase(name)}',
+const ${toCamelCase(namespace)}Item: Data.Object = {
+  name: '${namespace}_item',
+  label: '${toTitleCase(namespace)} Item',
   ownership: 'own',
   fields: {
     name: {
@@ -117,7 +141,7 @@ const ${toCamelCase(name)}: Data.Object = {
   },
 };
 
-export default ${toCamelCase(name)};
+export default ${toCamelCase(namespace)}Item;
 `,
     },
   },
@@ -142,13 +166,13 @@ export default ${toCamelCase(name)};
       test: 'vitest run',
       typecheck: 'tsc --noEmit',
     },
-    configContent: (name: string) => `import { defineStack } from '@objectstack/spec';
+    configContent: (name: string, namespace: string) => `import { defineStack } from '@objectstack/spec';
 import * as objects from './src/objects';
 
 export default defineStack({
   manifest: {
     id: 'com.objectstack.plugin-${name}',
-    namespace: 'plugin_${name}',
+    namespace: '${namespace}',
     version: '0.1.0',
     type: 'plugin',
     name: '${toTitleCase(name)} Plugin',
@@ -159,13 +183,13 @@ export default defineStack({
 });
 `,
     srcFiles: {
-      'src/objects/index.ts': (name) => `export { default as ${toCamelCase(name)} } from './${name}';
+      'src/objects/index.ts': (_name, namespace) => `export { default as ${toCamelCase(namespace)}Item } from './${namespace}_item';
 `,
-      'src/objects/__name__.ts': (name) => `import * as Data from '@objectstack/spec/data';
+      'src/objects/__name___item.ts': (_name, namespace) => `import * as Data from '@objectstack/spec/data';
 
-const ${toCamelCase(name)}: Data.Object = {
-  name: '${name}',
-  label: '${toTitleCase(name)}',
+const ${toCamelCase(namespace)}Item: Data.Object = {
+  name: '${namespace}_item',
+  label: '${toTitleCase(namespace)} Item',
   ownership: 'own',
   fields: {
     name: {
@@ -176,7 +200,7 @@ const ${toCamelCase(name)}: Data.Object = {
   },
 };
 
-export default ${toCamelCase(name)};
+export default ${toCamelCase(namespace)}Item;
 `,
     },
   },
@@ -199,12 +223,12 @@ export default ${toCamelCase(name)};
       validate: 'objectstack validate',
       typecheck: 'tsc --noEmit',
     },
-    configContent: (name: string) => `import { defineStack } from '@objectstack/spec';
+    configContent: (name: string, namespace: string) => `import { defineStack } from '@objectstack/spec';
 
 export default defineStack({
   manifest: {
-    id: 'com.example.${name}',
-    namespace: '${name}',
+    id: 'com.example.${namespace}',
+    namespace: '${namespace}',
     version: '0.1.0',
     type: 'app',
     name: '${toTitleCase(name)}',
@@ -343,7 +367,14 @@ export default class Init extends Command {
       this.error('objectstack.config.ts already exists');
     }
 
+    // Convert the npm-name (which allows hyphens, dots, scopes) into a
+    // valid ObjectStack namespace identifier. Threaded into every template
+    // function so object names use `${namespace}_${shortName}` form and
+    // satisfy `defineStack()` validation.
+    const namespace = sanitizeNamespace(projectName);
+
     printKV('Project', projectName);
+    printKV('Namespace', namespace);
     printKV('Template', `${flags.template} — ${template.description}`);
     printKV('Directory', targetDir);
     console.log('');
@@ -374,7 +405,7 @@ export default class Init extends Command {
       }
 
       // 2. Create objectstack.config.ts
-      const configContent = template.configContent(projectName);
+      const configContent = template.configContent(projectName, namespace);
       fs.writeFileSync(path.join(targetDir, 'objectstack.config.ts'), configContent);
       createdFiles.push('objectstack.config.ts');
 
@@ -400,17 +431,20 @@ export default class Init extends Command {
         createdFiles.push('tsconfig.json');
       }
 
-      // 4. Create src files
+      // 4. Create src files. File paths use `__name__` as a placeholder for
+      // the namespace (NOT the npm name) so generated identifiers stay snake
+      // _case even when the project name contains hyphens (e.g. `my-app` →
+      // namespace `my_app` → `src/objects/my_app_item.ts`).
       for (const [filePath, contentFn] of Object.entries(template.srcFiles)) {
-        const resolvedPath = filePath.replace('__name__', projectName);
+        const resolvedPath = filePath.replace(/__name__/g, namespace);
         const fullPath = path.join(targetDir, resolvedPath);
         const dir = path.dirname(fullPath);
 
         if (!fs.existsSync(dir)) {
           fs.mkdirSync(dir, { recursive: true });
         }
 
-        fs.writeFileSync(fullPath, contentFn(projectName));
+        fs.writeFileSync(fullPath, contentFn(projectName, namespace));
         createdFiles.push(resolvedPath);
       }
 
@@ -442,6 +476,30 @@ export default class Init extends Command {
         }
       }
 
+      // Self-test the scaffold so we catch template regressions (e.g. an
+      // invalid namespace or object name) before the user discovers them by
+      // running `objectstack dev`. Only runs when deps are present —
+      // `defineStack()` validation lives in `@objectstack/spec`.
+      if (installSucceeded) {
+        printStep('Validating scaffold...');
+        try {
+          const { bundleRequire } = await import('bundle-require');
+          const { mod } = await bundleRequire({
+            filepath: path.join(targetDir, 'objectstack.config.ts'),
+            cwd: targetDir,
+          });
+          const stack = mod.default ?? mod;
+          if (!stack?.manifest?.namespace) {
+            throw new Error('Rendered config has no manifest.namespace');
+          }
+          printSuccess(`Scaffold validated (namespace: ${stack.manifest.namespace})`);
+        } catch (err: any) {
+          printError(`Scaffold validation failed: ${err.message || err}`);
+          console.log(chalk.dim('  This is a CLI bug — please report it at https://github.com/objectstack-ai/framework/issues'));
+          this.error('Scaffold validation failed');
+        }
+      }
+
       if (!installAttempted || installSucceeded) {
         printSuccess('Project initialized!');
         console.log('');

packages/cli/test/init.test.ts

@@ -2,9 +2,10 @@
 
 import { describe, it, expect } from 'vitest';
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { TEMPLATES, getCliVersion, detectPackageManager } from '../src/commands/init';
+import { TEMPLATES, getCliVersion, detectPackageManager, sanitizeNamespace } from '../src/commands/init';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(
@@ -50,6 +51,95 @@ describe('init command — published scaffold', () => {
   });
 });
 
+describe('sanitizeNamespace', () => {
+  const NS_RE = /^[a-z][a-z0-9_]{1,19}$/;
+
+  it.each([
+    ['my-app', 'my_app'],
+    ['@acme/my-app', 'my_app'],
+    ['MyApp', 'myapp'],
+    ['hello.world', 'hello_world'],
+    ['a', 'a_app'],
+  ])('sanitizes %s → %s', (input, expected) => {
+    expect(sanitizeNamespace(input)).toBe(expected);
+  });
+
+  it('prefixes a leading digit so identifier starts with a letter', () => {
+    const out = sanitizeNamespace('123app');
+    expect(out).toMatch(NS_RE);
+    expect(out.startsWith('a')).toBe(true);
+  });
+
+  it('avoids reserved namespaces', () => {
+    expect(sanitizeNamespace('sys')).toBe('sys_app');
+    expect(sanitizeNamespace('base')).toBe('base_app');
+    expect(sanitizeNamespace('system')).toBe('system_app');
+  });
+
+  it('always produces a value matching the manifest namespace regex', () => {
+    for (const input of ['my-app', '@acme/my-app', '123app', 'sys', 'a', 'A__B', 'really-long-name-truncated-here']) {
+      expect(sanitizeNamespace(input)).toMatch(NS_RE);
+    }
+  });
+});
+
+describe('scaffold rendering — round-trip', () => {
+  // Re-implement the file-resolution logic from init.ts so we can verify
+  // rendered output without spawning a child CLI process.
+  function renderTemplate(templateKey: keyof typeof TEMPLATES, projectName: string) {
+    const t = TEMPLATES[templateKey];
+    const namespace = sanitizeNamespace(projectName);
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'os-init-'));
+    fs.writeFileSync(
+      path.join(tmpRoot, 'objectstack.config.ts'),
+      t.configContent(projectName, namespace),
+    );
+    const written: string[] = ['objectstack.config.ts'];
+    for (const [filePath, contentFn] of Object.entries(t.srcFiles)) {
+      const resolvedPath = filePath.replace(/__name__/g, namespace);
+      const fullPath = path.join(tmpRoot, resolvedPath);
+      fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+      fs.writeFileSync(fullPath, contentFn(projectName, namespace));
+      written.push(resolvedPath);
+    }
+    return { tmpRoot, namespace, written };
+  }
+
+  it('renders kebab project name into snake_case file paths and identifiers (app template)', () => {
+    const { tmpRoot, namespace, written } = renderTemplate('app', 'my-app');
+    expect(namespace).toBe('my_app');
+    // No file should contain a hyphen in its path segments.
+    for (const rel of written) {
+      expect(rel).not.toMatch(/-/);
+    }
+    // Object file is namespace-prefixed.
+    const objFile = path.join(tmpRoot, 'src', 'objects', 'my_app_item.ts');
+    expect(fs.existsSync(objFile)).toBe(true);
+    const objSrc = fs.readFileSync(objFile, 'utf8');
+    // Rendered object name must satisfy `${namespace}_${shortName}`.
+    expect(objSrc).toMatch(/name: 'my_app_item'/);
+    // Index re-exports the canonical identifier.
+    const indexSrc = fs.readFileSync(path.join(tmpRoot, 'src', 'objects', 'index.ts'), 'utf8');
+    expect(indexSrc).toMatch(/from '\.\/my_app_item'/);
+    expect(indexSrc).toMatch(/myAppItem/);
+    // Rendered config embeds the sanitized namespace.
+    const cfg = fs.readFileSync(path.join(tmpRoot, 'objectstack.config.ts'), 'utf8');
+    expect(cfg).toMatch(/namespace: 'my_app'/);
+    expect(namespace).toMatch(/^[a-z][a-z0-9_]{1,19}$/);
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  it('renders namespace identifiers identically for plugin and empty templates', () => {
+    for (const key of ['plugin', 'empty'] as const) {
+      const { tmpRoot, namespace } = renderTemplate(key, 'my-app');
+      expect(namespace).toBe('my_app');
+      const cfg = fs.readFileSync(path.join(tmpRoot, 'objectstack.config.ts'), 'utf8');
+      expect(cfg).toMatch(/namespace: 'my_app'/);
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+});
+
 describe('detectPackageManager', () => {
   it('detects pnpm from npm_config_user_agent', () => {
     expect(detectPackageManager({ npm_config_user_agent: 'pnpm/10.31.0 npm/? node/v22.0.0 linux x64' })).toBe('pnpm');

packages/create-objectstack/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-objectstack",
-  "version": "6.5.1",
+  "version": "6.5.2",
   "description": "Create a new ObjectStack project — npx create-objectstack",
   "bin": {
     "create-objectstack": "./bin/create-objectstack.js"