@vizualmodel/vmblu-cli 0.4.0 → 0.4.2

package/README.md

@@ -1,59 +1,66 @@
-# CLI for vmblu
-This folder contains the CLI commands that are available for vmblu.
-
-## Folder layout
-
-```txt
-vmblu/
-  cli/                      # your CLI source
-    commands/
-      init/
-      profile/
-      migrate/
-    templates/
-      x.y.z/                # a directory per version x.y.z
-        vmblu.schema.json
-        vmblu.annex.md
-        seed.md
-        srcdoc.schema.json
-    bin/
-      vmblu.js             # the executable (router)
-    package.json
-    README.md
-```
-
-## Add more commands
-
-Create commands/migrate/index.js with the same export shape { command, describe, builder, handler }. The router auto-discovers it.
-
-## Dev/test workflow
-
-### from vmblu/cli
-
-```bash
-npm link               # exposes "vmblu" globally
-vmblu init my-app --schema 0.8.2
-vmblu --help
-vmblu init --help
-```
-### Publish & use
-```bash
-npm publish --access public
-```
-## Usage
-
-```bash
-npx @vizualmodel/vmblu-cli init my-app --schema 0.8.2
-```
-
-**or, after global install:**
-
-```bash
-vmblu init my-app
-```
-## Tips
-
-* Keep templates inside the package and list them in "files" so npx works offline.
-* If you later prefer a richer UX, you can swap the router to commander/yargs without changing your command folders.
-* If your main repo houses both runtime and CLI, publish the CLI from vmblu/cli (separate package.json). This keeps runtime installs lean.
+# CLI for vmblu
+This folder contains the CLI commands that are available for vmblu.
+
+## Folder layout
+
+```txt
+vmblu/
+  cli/                      # your CLI source
+    bin/
+      vmblu.js              # discovers and adds commands
+    commands/
+      init/
+      make-app/
+      make-test/
+      profile/
+      migrate/
+    templates/
+      x.y.z/                # a directory per version x.y.z
+        blueprint.schema.json
+        blueprint.annex.md
+        vizual.schema.json
+        profile.schema.json
+        system-prompt.project.md
+        system-prompt.dev.md
+        system-prompt.test.md
+    package.json
+    README.md
+    LICENSE.txt
+```
+
+## Add more commands
+
+Create commands/migrate/index.js with the same export shape { command, describe, builder, handler }. The router auto-discovers it.
+
+## Dev/test workflow
+
+### from vmblu/cli
+
+```bash
+npm link               # exposes "vmblu" globally
+vmblu init my-app --schema 0.8.2
+vmblu --help
+vmblu init --help
+```
+### Publish & use
+
+```bash
+npm publish --access public
+```
+## Usage
+
+```bash
+npx @vizualmodel/vmblu-cli init my-app --schema 0.8.2
+```
+
+**or, after global install:**
+
+```bash
+vmblu init my-app
+```
+## Tips
+
+* Keep templates inside the package and list them in "files" so npx works offline.
+* If you later prefer a richer UX, you can swap the router to commander/yargs without changing your command folders.
+* If your main repo houses both runtime and CLI, publish the CLI from vmblu/cli (separate package.json). This keeps runtime installs lean.
 * This gives you one tidy package for all current and future commands, with zero drift and easy discoverability.

package/bin/vmblu.js

@@ -30,7 +30,7 @@ async function run() {
 
   if (['-v', '--version', 'version'].includes(cmd)) {
     const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-    console.log(pkg.version);
+    console.log('version: ' + pkg.version + ' schema: ' + pkg.schemaVersion);
     process.exit(0);
   }
 

package/commands/init/init-project.js

@@ -63,29 +63,22 @@ function defaultModel(projectName) {
       utc: now,
       style: "#2c7be5",
       runtime: "@vizualmodel/vmblu-runtime",
-      description: `${projectName} — vmblu model (scaffolded)`
+      description: `${projectName} - vmblu model (scaffolded)`
     },
-    models: [],
+    imports: [],
     factories: [],
+    types: {},
     root: {
-      group: "Root",
-      pins: [],
+      kind: "group",
+      name: "Root",
+      prompt: "Root group for the application.",
+      interfaces: [],
       nodes: [],
-      routes: [],
-      prompt: "Root group for the application."
+      connections: []
     }
   }, null, 2);
 }
 
-function defaultDoc(projectName) {
-  const now = new Date().toISOString();
-  return JSON.stringify({
-    version: CLI_VERSION,
-    generatedAt: now,
-    entries: {}
-  }, null, 2);
-}
-
 function fallbackAnnex() {
   return `# vmblu Annex (placeholder)
 This is a minimal scaffold. Replace with the official annex matching your pinned schema version.
@@ -124,23 +117,9 @@ function fallbackProfileSchema() {
 }`;
 }
 
-function fallbackSeed() {
-  return `# Session Seed (System Prompt)
-
-vmblu (Vizual Model Blueprint) is a graphical editor that maintains a visual, runnable model of a software system.
-vmblu models software as interconnected nodes that pass messages via pins.  
-The model has a well defined format described by a schema. An additional annex gives semantic background information about the schema.
-The parameter profiles of messages and where in the actual source code messages are received and sent, is stored in a second file, the profile file.
-The profile file is generated automatically by vmblu and is only to be consulted, not written.
-
-You are an expert **architecture + code copilot** for **vmblu** .
-You can find the location of the model file, the model schema, the model annex, the profile file and the profile schema in the 'manifest.json' file of this project.
-The location of all other files in the project can be found via the model file.
-
-Your job is to co-design the architecture and the software for the system.
-For modifications of the model, always follow the schema. 
-If the profile does not contain profile information it could be that the code for a message has not been written yet, this should not stop you from continuing
-`}
+function fallbackPrompt(promptType) {
+  return `# Missing prompt for ${promptType}`
+}
 
 /**
  * Initialize a vmblu project directory.
@@ -175,8 +154,7 @@ async function initProject(opts) {
   if (!targetDir) throw new Error("initProject: targetDir is required");
 
   const absTarget = path.resolve(targetDir);
-  const modelFile = path.join(absTarget, `${projectName}.blu.json`);
-  // const docFile   = path.join(absTarget, `${projectName}.prf.json`);
+  const modelFile = path.join(absTarget, `${projectName}.mod.blu`);
 
   const llmDir     = path.join(absTarget, 'llm');
   //const sessionDir = path.join(llmDir, 'session');
@@ -187,7 +165,9 @@ async function initProject(opts) {
   const annexSrc  = path.join(templatesDir, schemaVersion, 'blueprint.annex.md');
   const vizualSrc = path.join(templatesDir, schemaVersion, 'vizual.schema.json');
   const profileSchemaSrc = path.join(templatesDir, schemaVersion, 'profile.schema.json');
-  const promptSrc = path.join(templatesDir, schemaVersion, 'system-prompt.md');
+  const promptPrj = path.join(templatesDir, schemaVersion, 'system-prompt.project.md');
+  const promptDev = path.join(templatesDir, schemaVersion, 'system-prompt.dev.md');
+  const promptTst = path.join(templatesDir, schemaVersion, 'system-prompt.test.md');
   
   // 1) Create folders
   //for (const dir of [absTarget, llmDir, sessionDir, nodesDir]) {
@@ -200,16 +180,14 @@ async function initProject(opts) {
   ui.info(`create ${modelFile}${force ? ' (force)' : ''}`);
   await writeFileSafe(modelFile, defaultModel(projectName), { force, dry: dryRun });
 
-  //ui.info(`create ${docFile}${force ? ' (force)' : ''}`);
-  //await writeFileSafe(docFile, defaultDoc(projectName), { force, dry: dryRun });
-
   // 3) Copy schema + annex into llm/
   const schemaDst = path.join(llmDir, 'blueprint.schema.json');
   const annexDst  = path.join(llmDir, 'blueprint.annex.md');
   const vizualDst = path.join(llmDir, 'vizual.schema.json');
   const profileSchemaDst = path.join(llmDir, 'profile.schema.json');
-  const promptDst  = path.join(llmDir, 'system-prompt.md');
-
+  const promptPrjDst  = path.join(llmDir, 'system-prompt.project.md');
+  const promptDevDst  = path.join(llmDir, 'system-prompt.dev.md');
+  const promptTstDst  = path.join(llmDir, 'system-prompt.test.md');
 
   ui.info(`copy ${schemaSrc} -> ${schemaDst}${force ? ' (force)' : ''}`);
   await copyOrWriteFallback(schemaSrc, schemaDst, fallbackSchema(), { force, dry: dryRun });
@@ -223,49 +201,16 @@ async function initProject(opts) {
    ui.info(`copy ${profileSchemaSrc} -> ${profileSchemaDst}${force ? ' (force)' : ''}`);
   await copyOrWriteFallback(profileSchemaSrc, profileSchemaDst, fallbackProfileSchema(), { force, dry: dryRun });
 
-  ui.info(`copy ${promptSrc} -> ${promptDst}${force ? ' (force)' : ''}`);
-  await copyOrWriteFallback(promptSrc, promptDst, fallbackSeed(), { force, dry: dryRun });
-
-  /*
+  ui.info(`copy ${promptPrj} -> ${promptPrjDst}${force ? ' (force)' : ''}`);
+  await copyOrWriteFallback(promptPrj, promptPrjDst, fallbackPrompt('project'), { force, dry: dryRun });
 
-  // 4) Build manifest with hashes
-  const willWriteManifest = !(await exists(path.join(llmDir, 'manifest.json'))) || force;
-  let manifest = null;
+  ui.info(`copy ${promptDev} -> ${promptDevDst}${force ? ' (force)' : ''}`);
+  await copyOrWriteFallback(promptDev, promptDevDst, fallbackPrompt('development'), { force, dry: dryRun });
 
-  if (dryRun) {
-    ui.info(`would write manifest.json in ${llmDir}`);
-  } else {
+  ui.info(`copy ${promptTst} -> ${promptTstDst}${force ? ' (force)' : ''}`);
+  await copyOrWriteFallback(promptTst, promptTstDst, fallbackPrompt('test'), { force, dry: dryRun });
 
-    // I don't need the hashes
-    // const [schemaHash, annexHash, modelHash, docHash] = await Promise.all([
-    //   sha256(schemaDst), sha256(annexDst), sha256(modelFile), sha256(docFile)
-    // ]);
-
-    // Paths in manifest should be relative to /llm to keep it portable
-    const llmPosix = llmDir; // absolute
-    manifest = {
-      version: schemaVersion,
-      model:  { 
-        path: rel(llmPosix, modelFile),
-        schema: 'vmblu.schema.json',
-        annex: 'vmblu.annex.md',
-      },
-      profile: { 
-        path: rel(llmPosix, docFile), 
-        schema: 'profile.schema.json',
-      },
-    };
-
-    if (willWriteManifest) {
-      const manifestPath = path.join(llmDir, 'manifest.json');
-      ui.info(`create ${manifestPath}${force ? ' (force)' : ''}`);
-      await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
-    } else {
-      ui.warn(`manifest.json exists and --force not set. Skipped.`);
-    }
-  }
-  
-  */
+  // 4) Build manifest with hashes DELETED
 
   // 5) Make the package file
   makePackageJson({ absTarget, projectName, force, dryRun, addCliDep: true, cliVersion: "^" + CLI_VERSION }, ui);
@@ -276,7 +221,9 @@ async function initProject(opts) {
     ${path.basename(modelFile)}
     package.json
     llm/
-      system-prompt.md
+      system-prompt.project.md
+      system-prompt.dev.md
+      system-prompt.test.md
       blueprint.schema.json
       blueprint.annex.md
       vizual.schema.json
@@ -289,9 +236,9 @@ async function initProject(opts) {
     schemaVersion,
     files: {
       model: modelFile,
-      doc: docFile,
       schema: schemaDst,
       annex: annexDst,
+      vizualSchema: vizualDst,
       profileSchema: profileSchemaDst,
       // manifest: path.join(llmDir, 'manifest.json')
     },

package/commands/make-app/index.js

@@ -0,0 +1,108 @@
+// vmblu make-app <model-file> [--out <file>]
+import fs from 'fs';
+import path from 'path';
+
+import { ModelBlueprint, ModelCompiler } from '../../../core/model/index.js';
+import { ARL } from '../../../core/arl/arl-node.js';
+import { normalizeSeparators } from '../../../core/arl/path.js';
+import { UIDGenerator } from '../../../core/document/uid-generator.js';
+
+export const command = 'make-app <model-file>';
+export const describe = 'Generate an application JS file from a model';
+
+export const builder = [
+  { flag: '--out <file>', desc: 'specifies the output file' }
+];
+
+export const handler = async (argv) => {
+  // Parse the CLI arguments into a structured object.
+  const args = parseCliArgs(argv);
+
+  // Require a model file path to proceed.
+  if (!args.modelFile) {
+    console.error('Usage: vmblu make-app <model-file> [--out <file>]');
+    process.exit(1);
+  }
+
+  // Resolve and validate the model file path.
+  const absoluteModelPath = path.resolve(args.modelFile);
+  if (!fs.existsSync(absoluteModelPath) || !fs.statSync(absoluteModelPath).isFile()) {
+    console.error(args.modelFile, 'is not a file');
+    process.exit(1);
+  }
+
+  // Normalize to forward slashes so ARL resolution is consistent.
+  const modelPath = normalizeSeparators(absoluteModelPath);
+
+  // Compute the output path (default: <model>.app.js).
+  const outPath = args.outFile
+    ? path.resolve(args.outFile)
+    : (() => {
+        const { dir, name, ext } = path.parse(absoluteModelPath);
+        const baseName = ext === '.blu' && name.endsWith('.mod')
+          ? name.slice(0, -'.mod'.length)
+          : name;
+        return path.join(dir, `${baseName}.app.js`);
+      })();
+
+  // Normalize output path for the model app writer.
+  const appPath = normalizeSeparators(outPath);
+
+  // Build the model root via the compiler.
+  const arl = new ARL(modelPath);
+  const model = new ModelBlueprint(arl);
+  const compiler = new ModelCompiler(new UIDGenerator());
+
+  // Compile the model into a root node.
+  const root = await compiler.getRoot(model);
+  if (!root) {
+    console.error('Failed to compile model root.');
+    process.exit(1);
+  }
+
+  // Build runtime connection tables from the compiled routes.
+  root.rxtxBuildTxTable();
+
+  // Generate and save the app file from the compiled model.
+  model.makeAndSaveApp(appPath, root);
+  console.log(`App written to ${outPath}`);
+};
+
+function parseCliArgs(argvInput) {
+  // Accept argv as-is when already an array.
+  const argv = Array.isArray(argvInput) ? argvInput : [];
+  const result = {
+    modelFile: null,
+    outFile: null,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    // Handle the --out flag which expects a following path.
+    if (token === '--out') {
+      const next = argv[i + 1];
+      if (next && !next.startsWith('--')) {
+        result.outFile = next;
+        i += 1;
+      } else {
+        console.warn('Warning: --out requires a path argument; ignoring.');
+      }
+      continue;
+    }
+
+    // Warn on unknown options but keep parsing.
+    if (token?.startsWith('--')) {
+      console.warn(`Warning: unknown option "${token}" ignored.`);
+      continue;
+    }
+
+    // Treat the first positional token as the model file.
+    if (!result.modelFile) {
+      result.modelFile = token;
+    } else {
+      console.warn(`Warning: extra positional argument "${token}" ignored.`);
+    }
+  }
+
+  return result;
+}

package/commands/make-test/index.js

@@ -0,0 +1,103 @@
+// vmblu make-test <model-file> [--outDir <dir>]
+import fs from 'fs';
+import path from 'path';
+
+import { ModelBlueprint, ModelCompiler } from '../../../core/model/index.js';
+import { ARL } from '../../../core/arl/arl-node.js';
+import { UIDGenerator } from '../../../core/document/uid-generator.js';
+import { normalizeSeparators } from '../../../core/arl/path.js';
+
+export const command = 'make-test <model-file>';
+export const describe = 'Generate test app files from a model';
+
+export const builder = [
+  { flag: '--out-dir <dir>', desc: 'output directory for test files (default: ./test)' },
+  { flag: '--out <dir>', desc: 'alias for --out-dir' },
+  { flag: '-o <dir>', desc: 'alias for --out-dir' }
+];
+
+export const handler = async (argv) => {
+  const args = parseCliArgs(argv);
+
+  // Require a model file path to proceed.
+  if (!args.modelFile) {
+    console.error('Usage: vmblu make-test <model-file> [--outDir <dir>]');
+    process.exit(1);
+  }
+
+  // Resolve and validate the model file path.
+  const absoluteModelPath = path.resolve(args.modelFile);
+  if (!fs.existsSync(absoluteModelPath) || !fs.statSync(absoluteModelPath).isFile()) {
+    console.error(args.modelFile, 'is not a file');
+    process.exit(1);
+  }
+
+  // Resolve the output directory (default: <model-dir>/test).
+  const outDir = args.outDir
+    ? path.resolve(args.outDir)
+    : path.join(path.dirname(absoluteModelPath), 'test');
+
+  // Ensure the output directory exists.
+  if (!fs.existsSync(outDir)) {
+    fs.mkdirSync(outDir, { recursive: true });
+    const mirrorsDir = path.join(outDir, 'mirrors');
+    fs.mkdirSync(mirrorsDir, { recursive: true });
+  }
+
+  // Normalize to forward slashes so ARL resolution is consistent.
+  const modelPath = normalizeSeparators(absoluteModelPath);
+
+  // Build the model root via the compiler.
+  const arl = new ARL(modelPath);
+  const model = new ModelBlueprint(arl);
+  const compiler = new ModelCompiler(new UIDGenerator());
+
+  // Compile the model into a root node.
+  const root = await compiler.getRoot(model);
+  if (!root) {
+    console.error('Failed to compile model root.');
+    process.exit(1);
+  }
+
+  // Build runtime connection tables from the compiled routes.
+  root.rxtxBuildTxTable();
+
+  // Generate and save the test app files from the compiled model.
+  model.makeTestApp(normalizeSeparators(outDir), root);
+  console.log(`Test app written to ${outDir}`);
+};
+
+function parseCliArgs(argvInput) {
+  const argv = Array.isArray(argvInput) ? argvInput : [];
+  const result = {
+    outDir: null,
+    modelFile: null,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === '--out-dir' || token === '--out' || token === '-o') {
+      const next = argv[i + 1];
+      if (next && !next.startsWith('--')) {
+        result.outDir = next;
+        i += 1;
+      } else {
+        console.warn('Warning: --out-dir requires a path argument; ignoring.');
+      }
+      continue;
+    }
+
+    if (token?.startsWith('--')) {
+      console.warn(`Warning: unknown option "${token}" ignored.`);
+      continue;
+    }
+
+    if (!result.modelFile) {
+      result.modelFile = token;
+    } else {
+      console.warn(`Warning: extra positional argument "${token}" ignored.`);
+    }
+  }
+
+  return result;
+}