pixifact-cli 0.3.0 → 0.5.0

package/src/pixifact-cli.ts

@@ -3,16 +3,23 @@ import { createPixifactAutomation } from './automation';
 import { hintForCommandError } from 'pixifact';
 import { CompileSceneError, compileScenes } from 'pixifact/compiler-node';
 import type { SceneValidationDiagnostic } from 'pixifact/compiler';
-import { createLiveBridgeServer } from './liveBridgeServer';
+import { startEditorServer } from './editorServer';
+import { queryEditorContext } from './editorSession';
+import {
+    buildWechatTarget,
+    devWechatTarget,
+    validateWechatTarget,
+    type WechatDevEvent,
+    WechatTargetError,
+} from './wechatTarget';
 
 type Automation = ReturnType<typeof createPixifactAutomation>;
-type LiveBridge = Pick<ReturnType<typeof createLiveBridgeServer>, 'connected' | 'callAction' | 'stop'> & {
-    waitForConnection?: (timeoutMs?: number) => Promise<void>;
-};
 
 interface CliOptions {
     automation?: Automation;
-    liveBridge?: LiveBridge;
+    onWechatDevEvent?: (event: WechatDevEvent) => void;
+    readEditorContext?: typeof queryEditorContext;
+    startEditor?: typeof startEditorServer;
 }
 
 interface CliResult {
@@ -88,6 +95,15 @@ function isFailedResult(value: unknown): value is CliJsonResult {
 function compileScenesFailure(error: unknown): CliJsonResult {
     const message = error instanceof Error ? error.message : String(error);
     if (error instanceof CompileSceneError) {
+        if (error.diagnostics) {
+            return {
+                ok: false,
+                scene: error.scene,
+                error: 'Scene compile failed.',
+                diagnostics: error.diagnostics,
+                hint: 'Fix the listed diagnostics, then run compile-scenes again.',
+            };
+        }
         const sourceDiagnostic = sourceDiagnosticFromMessage(error.source ?? '', message);
         if (sourceDiagnostic) {
             return {
@@ -205,10 +221,99 @@ function sourcePositionFromMessage(source: string, message: string) {
     };
 }
 
-async function executeFileCommand(positionals: string[], flags: Record<string, string | true>, automation: Automation) {
+async function executeFileCommand(
+    positionals: string[],
+    flags: Record<string, string | true>,
+    automation: Automation,
+    onWechatDevEvent?: (event: WechatDevEvent) => void,
+    startEditor: typeof startEditorServer = startEditorServer,
+    readEditorContext: typeof queryEditorContext = queryEditorContext,
+) {
     const [area, action] = positionals;
     const projectRoot = projectRootFlag(flags);
 
+    if (area === 'editor' && action === undefined) {
+        const session = await startEditor({ projectRoot });
+        return {
+            ok: true,
+            projectRoot,
+            url: session.url,
+        };
+    }
+
+    if (area === 'editor' && action === 'context') {
+        return readEditorContext({ projectRoot });
+    }
+
+    if ((area === 'build' || area === 'dev' || area === 'validate') && action === undefined) {
+        const target = requireFlag(flags, 'target');
+        if (target !== 'wechat') {
+            throw new Error(`Unknown Pixifact target "${target}".`);
+        }
+        if (area === 'validate') {
+            const result = await validateWechatTarget(projectRoot);
+            return result.diagnostics.length > 0
+                ? {
+                    ok: false,
+                    target,
+                    diagnostics: result.diagnostics,
+                    hint: 'Fix the listed WeChat target diagnostics, then validate again.',
+                }
+                : { ok: true, projectRoot, target };
+        }
+        if (area === 'dev') {
+            if (flags.mode !== undefined) {
+                throw new Error('dev --target wechat always uses development mode; remove --mode.');
+            }
+            try {
+                const session = await devWechatTarget(projectRoot, onWechatDevEvent);
+                return {
+                    ok: true,
+                    projectRoot,
+                    target,
+                    mode: 'development',
+                    watching: true,
+                    report: session.initialReport,
+                };
+            } catch (error) {
+                if (error instanceof WechatTargetError) {
+                    return {
+                        ok: false,
+                        target,
+                        error: error.message,
+                        diagnostics: error.diagnostics,
+                        hint: 'Fix the listed WeChat target diagnostics, then start dev again.',
+                    };
+                }
+                throw error;
+            }
+        }
+        const mode = flags.mode === undefined ? 'production' : requireFlag(flags, 'mode');
+        if (mode !== 'development' && mode !== 'production') {
+            throw new Error('--mode must be development or production.');
+        }
+        try {
+            return {
+                ok: true,
+                projectRoot,
+                target,
+                mode,
+                report: await buildWechatTarget(projectRoot, mode),
+            };
+        } catch (error) {
+            if (error instanceof WechatTargetError) {
+                return {
+                    ok: false,
+                    target,
+                    error: error.message,
+                    diagnostics: error.diagnostics,
+                    hint: 'Fix the listed WeChat target diagnostics, then build again.',
+                };
+            }
+            throw error;
+        }
+    }
+
     if (area === 'compile-scenes' && action === undefined) {
         try {
             await compileScenes({ projectRoot });
@@ -268,32 +373,7 @@ async function executeFileCommand(positionals: string[], flags: Record<string, s
     throw new Error(`Unknown Pixifact CLI command "${positionals.join(' ')}".`);
 }
 
-async function executeLiveCommand(positionals: string[], flags: Record<string, string | true>, bridge: LiveBridge) {
-    if (!bridge.connected && bridge.waitForConnection) {
-        await bridge.waitForConnection();
-    }
-    if (!bridge.connected) {
-        throw new Error('No live Pixifact editor is connected.');
-    }
-
-    const [area, action] = positionals;
-    if (area === 'summary' && action === undefined) {
-        return bridge.callAction('summary', {});
-    }
-    if (area === 'scene' && action === 'get') {
-        return bridge.callAction('scene.get', {});
-    }
-    if (area === 'node' && action === 'inspect') {
-        return bridge.callAction('node.inspect', {
-            node: requireFlag(flags, 'node'),
-        });
-    }
-
-    throw new Error(`Unknown Pixifact live command "${positionals.join(' ')}".`);
-}
-
 export async function executePixifactCli(argv: string[], options: CliOptions = {}): Promise<CliResult> {
-    let ownedBridge: ReturnType<typeof createLiveBridgeServer> | undefined;
     try {
         const parsed = parseArgs(argv);
         if (parsed.flags.help === true) {
@@ -305,19 +385,19 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
                         'scene inspect --scene <scene-path>',
                         'scene validate --scene <scene-path>',
                         'compile-scenes',
+                        'validate --target wechat',
+                        'build --target wechat',
+                        'dev --target wechat',
                     ],
                     aiValidationAlternatives: [
                         'scene validate --all',
                     ],
                     auxiliaryCommands: [
+                        'editor',
+                        'editor context',
                         'scene create --scene <scene-path> --name <SceneName>',
                         'node inspect --scene <scene-path> --node <locator>',
                     ],
-                    liveContextCommands: [
-                        'live summary',
-                        'live scene get',
-                        'live node inspect --node <locator>',
-                    ],
                     defaults: {
                         projectRoot: 'current working directory',
                     },
@@ -327,14 +407,14 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
         }
 
         const automation = options.automation ?? createPixifactAutomation();
-        const isLive = parsed.positionals[0] === 'live';
-        const result = isLive
-            ? await executeLiveCommand(
-                parsed.positionals.slice(1),
-                parsed.flags,
-                options.liveBridge ?? (ownedBridge = createLiveBridgeServer()),
-            )
-            : await executeFileCommand(parsed.positionals, parsed.flags, automation);
+        const result = await executeFileCommand(
+            parsed.positionals,
+            parsed.flags,
+            automation,
+            options.onWechatDevEvent,
+            options.startEditor,
+            options.readEditorContext,
+        );
         if (isFailedResult(result)) {
             return {
                 exitCode: 1,
@@ -357,13 +437,13 @@ export async function executePixifactCli(argv: string[], options: CliOptions = {
                 hint: hintForCommandError(error instanceof Error ? error.message : String(error)),
             }),
         };
-    } finally {
-        ownedBridge?.stop();
     }
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-    const result = await executePixifactCli(process.argv.slice(2));
+    const result = await executePixifactCli(process.argv.slice(2), {
+        onWechatDevEvent: (event) => process.stdout.write(jsonLine(event)),
+    });
     process.stdout.write(result.stdout);
     process.stderr.write(result.stderr);
     process.exitCode = result.exitCode;