@auto-engineer/narrative 0.11.11

package/scripts/convert-flow.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import { resolve, dirname, relative, join } from 'path';
+import { existsSync, writeFileSync, statSync } from 'fs';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const runInContext = (flowPath: string, projectRoot: string): Promise<string> => {
+  return new Promise((resolve, reject) => {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const helperScript = join(__dirname, 'convert-flow-helper.ts');
+
+    const child = spawn('npx', ['tsx', helperScript, flowPath], {
+      cwd: projectRoot,
+      stdio: ['inherit', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data: string) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data: string) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`Process failed with code ${code}: ${stderr}`));
+      }
+    });
+  });
+};
+
+const validateArgs = (args: string[]): void => {
+  if (args.length === 0) {
+    console.error('Usage: pnpm convert-flow <input-file.flow.ts> [output-file-or-dir]');
+    process.exit(1);
+  }
+};
+
+const validateInputFile = (inputFile: string): void => {
+  if (!inputFile.endsWith('.flow.ts') && !inputFile.endsWith('.flow.js')) {
+    console.error('Error: Input file must be a .flow.ts or .flow.js file');
+    process.exit(1);
+  }
+};
+
+const validateInputPath = (inputPath: string): void => {
+  if (!existsSync(inputPath)) {
+    console.error(`Error: File not found: ${inputPath}`);
+    process.exit(1);
+  }
+};
+
+const resolveOutputPath = (outputFile: string | undefined): string | undefined => {
+  if (outputFile === undefined || outputFile === '') {
+    return undefined;
+  }
+
+  const resolved = resolve(outputFile);
+  if (existsSync(resolved) && statSync(resolved).isDirectory()) {
+    return join(resolved, 'schema.json');
+  }
+  return resolved;
+};
+
+const findProjectRoot = (startDir: string): string => {
+  let projectRoot = startDir;
+  while (projectRoot !== '/' && !existsSync(`${projectRoot}/package.json`)) {
+    projectRoot = dirname(projectRoot);
+  }
+
+  if (!existsSync(`${projectRoot}/package.json`)) {
+    console.error('Error: Could not find package.json in flow directory or its parents');
+    process.exit(1);
+  }
+
+  return projectRoot;
+};
+
+const writeOutput = (outputPath: string | undefined, json: string): void => {
+  if (outputPath !== undefined && outputPath !== '') {
+    writeFileSync(outputPath, json);
+    console.log(`✓ Flow converted successfully to: ${outputPath}`);
+    console.log('📋 Schema validation performed during conversion');
+  } else {
+    console.log(json);
+  }
+};
+
+const main = async () => {
+  const args = process.argv.slice(2);
+  validateArgs(args);
+
+  const inputFile = args[0];
+  const outputFile = args[1];
+
+  validateInputFile(inputFile);
+
+  try {
+    const inputPath = resolve(inputFile);
+    validateInputPath(inputPath);
+
+    const outputPath = resolveOutputPath(outputFile);
+
+    console.log(`Converting flow: ${inputPath}`);
+
+    const flowDir = dirname(inputPath);
+    const projectRoot = findProjectRoot(flowDir);
+    const relativeFlowPath = relative(projectRoot, inputPath);
+
+    const json = await runInContext(relativeFlowPath, projectRoot);
+    writeOutput(outputPath, json);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error converting flow: ${message}`);
+    process.exit(1);
+  }
+};
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/scripts/print-schema.ts

@@ -0,0 +1,30 @@
+import {
+  CommandSliceSchema,
+  NarrativeSchema,
+  IntegrationSchema,
+  MessageSchema,
+  QuerySliceSchema,
+  ReactSliceSchema,
+} from '../src';
+
+import { zodToJsonSchema } from 'zod-to-json-schema';
+const schemas = Object.fromEntries(
+  Object.entries({
+    narrative: NarrativeSchema,
+    message: MessageSchema,
+    integration: IntegrationSchema,
+    commandSlice: CommandSliceSchema,
+    querySlice: QuerySliceSchema,
+    reactSlice: ReactSliceSchema,
+  }).map(([k, v]) => [
+    k,
+    zodToJsonSchema(v, {
+      $refStrategy: 'root',
+      target: 'jsonSchema7',
+      definitionPath: 'definitions',
+      name: k[0].toUpperCase() + k.slice(1),
+    }),
+  ]),
+);
+
+console.log(JSON.stringify(schemas, null, 2));

package/src/commands/export-schema-helper.ts

@@ -0,0 +1,76 @@
+import createDebug from 'debug';
+import { getFs } from './filestore.node';
+import { IExtendedFileStore, NodeFileStore } from '@auto-engineer/file-store';
+
+const debug = createDebug('auto:narrative:export-schema-helper');
+if ('color' in debug && typeof debug === 'object') {
+  (debug as { color: string }).color = '4';
+} // blue
+
+const main = async () => {
+  const directory = process.argv[2] || process.cwd();
+  debug('Starting export-schema-helper with directory: %s', directory);
+
+  try {
+    // Import getFlows from the project's node_modules to ensure we use the same module context
+    const getFileStore = getFs as () => Promise<IExtendedFileStore>;
+    const fs: IExtendedFileStore = await getFileStore();
+    const projectNarrativePath = fs.join(
+      directory,
+      'node_modules',
+      '@auto-engineer',
+      'narrative',
+      'dist',
+      'src',
+      'getNarratives.js',
+    );
+    debug('Importing getFlows from: %s', projectNarrativePath);
+
+    const { pathToFileURL } = await import('url');
+    const narrativeModule = (await import(pathToFileURL(projectNarrativePath).href)) as {
+      getNarratives: typeof import('../getNarratives').getNarratives;
+    };
+    const { getNarratives } = narrativeModule;
+
+    const narrativesPath = fs.join(directory, 'narratives');
+    debug('Resolved narratives path: %s', narrativesPath);
+
+    const result = await getNarratives({ vfs: new NodeFileStore(), root: narrativesPath });
+    const schema = result.toModel();
+    debug(
+      'Schema generated with %d narratives, %d messages, %d integrations',
+      schema.narratives.length,
+      schema.messages.length,
+      schema.integrations?.length ?? 0,
+    );
+
+    const json = JSON.stringify(schema, null, 2);
+    const contextDir = fs.join(directory, '.context');
+    const outPath = fs.join(contextDir, 'schema.json');
+
+    await fs.ensureDir(contextDir);
+    await fs.writeText(outPath, json);
+    debug('Schema written to: %s', outPath);
+
+    // Output success as JSON for parent process
+    console.log(
+      JSON.stringify({
+        success: true,
+        outputPath: outPath,
+      }),
+    );
+  } catch (error) {
+    debug('Error occurred: %o', error);
+
+    // Output error as JSON for parent process
+    console.log(
+      JSON.stringify({
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      }),
+    );
+    process.exit(1);
+  }
+};
+
+void main();

package/src/commands/export-schema-runner.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+// This runner is executed in the target directory context to avoid module resolution issues
+import { resolve } from 'path';
+import { writeFileSync, mkdirSync } from 'fs';
+import createDebug from 'debug';
+import { NodeFileStore } from '@auto-engineer/file-store';
+
+const debug = createDebug('auto:narrative:export-schema-runner');
+if ('color' in debug && typeof debug === 'object') {
+  (debug as { color: string }).color = '4';
+} // blue
+
+const main = async () => {
+  const contextDir = process.argv[2] || './.context';
+  const narrativesDir = process.argv[3] || './narratives';
+
+  debug('Starting export-schema-runner');
+  debug('  Context dir: %s', contextDir);
+  debug('  Flows dir: %s', narrativesDir);
+
+  try {
+    // Import from the installed package in the target directory
+    // This ensures we use the same module instance as the flow files
+    const narrative = await import('@auto-engineer/narrative');
+    const { getNarratives } = narrative;
+
+    if (typeof getNarratives !== 'function') {
+      throw new Error('getNarratives not found in @auto-engineer/narrative exports');
+    }
+
+    const narrativesPath = resolve(process.cwd(), narrativesDir);
+    debug('Resolved narratives path: %s', narrativesPath);
+
+    const result = await getNarratives({ vfs: new NodeFileStore(), root: narrativesPath });
+    const schema = result.toModel();
+    debug(
+      'Schema generated with %d narratives, %d messages, %d integrations',
+      schema.narratives.length,
+      schema.messages.length,
+      schema.integrations?.length ?? 0,
+    );
+
+    const json = JSON.stringify(schema, null, 2);
+    const resolvedContextDir = resolve(process.cwd(), contextDir);
+    const outPath = resolve(resolvedContextDir, 'schema.json');
+
+    mkdirSync(resolvedContextDir, { recursive: true });
+    writeFileSync(outPath, json);
+    debug('Schema written to: %s', outPath);
+
+    // Output success as JSON for parent process
+    console.log(
+      JSON.stringify({
+        success: true,
+        outputPath: outPath,
+      }),
+    );
+  } catch (error) {
+    debug('Error occurred: %o', error);
+
+    // Output error as JSON for parent process
+    console.log(
+      JSON.stringify({
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error occurred',
+      }),
+    );
+    process.exit(1);
+  }
+};
+
+void main();

package/src/commands/export-schema.ts

@@ -0,0 +1,157 @@
+import { type Command, type Event, defineCommandHandler } from '@auto-engineer/message-bus';
+import { getFs } from './filestore.node.js';
+import createDebug from 'debug';
+
+const debug = createDebug('auto:narrative:export-schema');
+if ('color' in debug && typeof debug === 'object') {
+  (debug as { color: string }).color = '4';
+}
+
+export type ExportSchemaCommand = Command<
+  'ExportSchema',
+  {
+    directory: string;
+  }
+>;
+
+export type SchemaExportedEvent = Event<
+  'SchemaExported',
+  {
+    directory: string;
+    outputPath: string;
+  }
+>;
+
+export type SchemaExportFailedEvent = Event<
+  'SchemaExportFailed',
+  {
+    directory: string;
+    error: string;
+  }
+>;
+
+export type ExportSchemaEvents = SchemaExportedEvent | SchemaExportFailedEvent;
+
+export const commandHandler = defineCommandHandler({
+  name: 'ExportSchema',
+  alias: 'export:schema',
+  description: 'Export flow schemas to context directory',
+  category: 'export',
+  icon: 'download',
+  events: ['SchemaExported', 'SchemaExportFailed'],
+  fields: {
+    directory: {
+      description: 'Context directory path',
+      required: true,
+    },
+  },
+  examples: ['$ auto export:schema --directory=./.context'],
+  handle: async (command: Command): Promise<SchemaExportedEvent | SchemaExportFailedEvent> => {
+    const typedCommand = command as ExportSchemaCommand;
+    const result = await handleExportSchemaCommand(typedCommand);
+    if (result.type === 'SchemaExported') {
+      debug('✅ Flow schema written to: %s', result.data.outputPath);
+    } else {
+      debug('❌ Failed to export schema: %s', result.data.error);
+    }
+    return result;
+  },
+});
+
+export async function handleExportSchemaCommand(
+  command: ExportSchemaCommand,
+): Promise<SchemaExportedEvent | SchemaExportFailedEvent> {
+  const { directory } = command.data;
+
+  try {
+    // Run the helper script with tsx
+    const fs = await getFs();
+    const __dirname = fs.dirname(new URL(import.meta.url).href);
+    const helperScript = fs.join(__dirname, 'export-schema-helper.js');
+    const { spawn } = await import('child_process');
+
+    return new Promise((resolve) => {
+      const child = spawn('npx', ['tsx', helperScript, directory], {
+        cwd: directory,
+        stdio: ['inherit', 'pipe', 'inherit'], // Let stderr go directly to parent process
+        env: {
+          ...process.env,
+          NODE_ENV: process.env.NODE_ENV ?? 'development',
+          DEBUG: process.env.DEBUG, // Explicitly pass DEBUG env var
+          DEBUG_COLORS: process.env.DEBUG_COLORS, // Pass color settings
+          DEBUG_HIDE_DATE: 'true', // Always hide timestamps in child process to match parent
+        },
+        shell: true,
+      });
+
+      let stdout = '';
+
+      child.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.on('close', (code) => {
+        try {
+          // Extract JSON from stdout - look for the last line that starts with '{'
+          const lines = stdout.trim().split('\n');
+          const jsonLine = lines.reverse().find((line) => line.trim().startsWith('{'));
+
+          if (jsonLine == null) {
+            throw new Error('No JSON output found');
+          }
+
+          const result = JSON.parse(jsonLine) as { success?: boolean; outputPath?: string; error?: string };
+          if (result.success === true) {
+            resolve({
+              type: 'SchemaExported',
+              data: {
+                directory,
+                outputPath: result.outputPath ?? '',
+              },
+              timestamp: new Date(),
+              requestId: command.requestId,
+              correlationId: command.correlationId,
+            });
+          } else {
+            resolve({
+              type: 'SchemaExportFailed',
+              data: {
+                directory,
+                error: result.error ?? 'Unknown error',
+              },
+              timestamp: new Date(),
+              requestId: command.requestId,
+              correlationId: command.correlationId,
+            });
+          }
+        } catch {
+          resolve({
+            type: 'SchemaExportFailed',
+            data: {
+              directory,
+              error: code === 0 ? 'Failed to parse result' : `Process failed with code ${code}`,
+            },
+            timestamp: new Date(),
+            requestId: command.requestId,
+            correlationId: command.correlationId,
+          });
+        }
+      });
+    });
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      type: 'SchemaExportFailed',
+      data: {
+        directory,
+        error: message,
+      },
+      timestamp: new Date(),
+      requestId: command.requestId,
+      correlationId: command.correlationId,
+    };
+  }
+}
+
+// Default export is the command handler
+export default commandHandler;

package/src/commands/filestore.node.ts

@@ -0,0 +1,12 @@
+import type { IExtendedFileStore } from '@auto-engineer/file-store';
+
+let fsPromise: Promise<IExtendedFileStore> | null = null;
+export async function getFs(): Promise<IExtendedFileStore> {
+  if (!fsPromise) {
+    fsPromise = (async () => {
+      const { NodeFileStore } = await import('@auto-engineer/file-store');
+      return new NodeFileStore() as IExtendedFileStore;
+    })();
+  }
+  return fsPromise;
+}