@noego/wood 0.0.1

package/README.md

@@ -0,0 +1,107 @@
+# @noego/wood
+
+Declarative Electron desktop apps using the noego ecosystem.
+
+`@noego/wood` provides config parsing, operation/view parsing, IPC routing, runtime wiring, code generation, and CLI utilities for building Electron applications with Svelte-based renderer flows.
+
+Note: temporary README test note added from the demo-assistant workspace.
+
+## Install
+
+```bash
+npm install @noego/wood
+```
+
+Peer dependencies used by the package include:
+
+- `electron >=28`
+- `svelte ^5`
+- `playwright ^1.40.0` (optional)
+- `better-sqlite3 ^11`
+- `sqlstack`
+- `@noego/proper`
+
+## Package Entry Points
+
+The package publishes both ESM and CommonJS builds through `exports`.
+
+Primary entry points:
+
+- `@noego/wood`
+- `@noego/wood/electron`
+- `@noego/wood/main`
+- `@noego/wood/client`
+- `@noego/wood/ipc`
+- `@noego/wood/navigation`
+- `@noego/wood/stick`
+- `@noego/wood/testing`
+- `@noego/wood/loader`
+
+Svelte component exports:
+
+- `@noego/wood/recursive-render`
+- `@noego/wood/navigation-shell`
+- `@noego/wood/components`
+
+## Core API
+
+The root package exports the main framework surface, including:
+
+- `parseConfig`
+- `parseOperations` and `parseOperationsFile`
+- `parseViews` and `parseViewsFile`
+- `WoodRouter`
+- `SchemaValidator`
+- `MiddlewareResolver`
+- `ControllerResolver`
+- `LoaderRunner`
+- `BackendBridge`
+- `WindowManager`
+- `runtime`
+- code generators such as `generatePreload`, `generateRuntime`, `generateRendererApp`, and `generateTypes`
+
+Example:
+
+```ts
+import { parseOperationsFile, parseViewsFile, generateRuntime } from '@noego/wood';
+
+const operations = parseOperationsFile('operations/chat.yaml');
+const views = parseViewsFile('views/app.yaml');
+
+const source = generateRuntime({
+  operations,
+  views,
+});
+```
+
+## CLI
+
+This package includes two executables:
+
+- `wood`
+- `stick`
+
+`wood` currently supports:
+
+```bash
+wood dev
+wood build
+```
+
+Both commands generate project artifacts and pass remaining options through to `electron-vite`.
+
+## Development
+
+Repository scripts:
+
+```bash
+npm run build
+npm run typecheck
+npm test
+```
+
+Publishing runs the same checks through `prepublishOnly`.
+
+## Design Notes
+
+High-level architecture and config format notes live in [DESIGN.md](./DESIGN.md).

package/bin/axe.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+import path from 'node:path';
+import process from 'node:process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const distDir = path.resolve(__dirname, '..', 'dist');
+
+const { readWoodDevMetadata } = await import(path.join(distDir, 'dev', 'dev_metadata.js'));
+
+const INTERNAL_BRIDGE_KEY = '__NOEGO_WOOD_BRIDGE__';
+
+function printUsage() {
+  console.log('Usage: axe <command> [options]');
+  console.log('');
+  console.log('Commands:');
+  console.log('  targets [--window <windowId>]      List attachable Wood windows');
+  console.log('  js [--window <windowId>]            Run JavaScript from stdin in the selected renderer');
+  console.log('  click <selector> [--window <id>]    Click an element');
+  console.log('  type <selector> <text> [--window <id>]  Fill an element');
+  console.log('  screenshot [path] [--window <id>]   Save a screenshot');
+}
+
+function parseArgs(argv) {
+  const positional = [];
+  let windowId = null;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--window') {
+      windowId = argv[i + 1] ?? null;
+      i += 1;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  return { positional, windowId };
+}
+
+async function loadPlaywright() {
+  try {
+    return await import('playwright');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`axe requires Playwright to be installed in this environment. ${message}`);
+  }
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return '';
+  }
+
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+  }
+  return chunks.join('');
+}
+
+async function connectBrowser(browserUrl) {
+  const playwright = await loadPlaywright();
+  return playwright.chromium.connectOverCDP(browserUrl);
+}
+
+async function listTargets(browser) {
+  const results = [];
+  for (const context of browser.contexts()) {
+    for (const page of context.pages()) {
+      let currentWindow = null;
+      try {
+        currentWindow = await page.evaluate(async (bridgeKey) => {
+          const bridge = globalThis[bridgeKey];
+          if (!bridge || typeof bridge !== 'object') {
+            return null;
+          }
+          const windowApi = bridge.__window;
+          if (!windowApi || typeof windowApi.current !== 'function') {
+            return null;
+          }
+          return await windowApi.current();
+        }, INTERNAL_BRIDGE_KEY);
+      } catch {
+        currentWindow = null;
+      }
+
+      results.push({
+        page,
+        windowId: currentWindow?.ok ? currentWindow.windowId ?? null : null,
+        defaultRoute: currentWindow?.ok ? currentWindow.defaultRoute ?? null : null,
+        title: await page.title().catch(() => ''),
+        url: page.url(),
+      });
+    }
+  }
+  return results;
+}
+
+async function resolveTarget(browser, requestedWindowId) {
+  const targets = await listTargets(browser);
+  if (targets.length === 0) {
+    throw new Error('No renderer targets found in the running Wood app.');
+  }
+
+  if (requestedWindowId) {
+    const match = targets.find((target) => target.windowId === requestedWindowId);
+    if (!match) {
+      throw new Error(`No Wood window target found for "${requestedWindowId}".`);
+    }
+    return match;
+  }
+
+  return targets[0];
+}
+
+async function main() {
+  const { positional, windowId } = parseArgs(process.argv.slice(2));
+  const command = positional[0];
+
+  if (!command) {
+    printUsage();
+    process.exit(0);
+  }
+
+  const metadata = readWoodDevMetadata(process.cwd());
+  const browser = await connectBrowser(metadata.browserUrl);
+
+  try {
+    if (command === 'targets') {
+      const targets = await listTargets(browser);
+      const lines = targets.map((target, index) => JSON.stringify({
+        index,
+        windowId: target.windowId,
+        defaultRoute: target.defaultRoute,
+        title: target.title,
+        url: target.url,
+      }));
+      process.stdout.write(`${lines.join('\n')}\n`);
+      return;
+    }
+
+    const target = await resolveTarget(browser, windowId);
+    const page = target.page;
+
+    if (command === 'js') {
+      const source = await readStdin();
+      if (!source.trim()) {
+        throw new Error('axe js expects JavaScript via stdin.');
+      }
+      const result = await page.evaluate(async (userSource) => {
+        const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+        return await new AsyncFunction(userSource)();
+      }, source);
+      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      return;
+    }
+
+    if (command === 'click') {
+      const selector = positional[1];
+      if (!selector) {
+        throw new Error('axe click requires a selector.');
+      }
+      await page.locator(selector).click();
+      process.stdout.write(`clicked ${selector}\n`);
+      return;
+    }
+
+    if (command === 'type') {
+      const selector = positional[1];
+      const text = positional[2];
+      if (!selector || text == null) {
+        throw new Error('axe type requires a selector and text.');
+      }
+      await page.locator(selector).fill(text);
+      process.stdout.write(`typed into ${selector}\n`);
+      return;
+    }
+
+    if (command === 'screenshot') {
+      const outputPath = positional[1]
+        ? path.resolve(process.cwd(), positional[1])
+        : path.resolve(process.cwd(), `axe-screenshot-${Date.now()}.png`);
+      await page.screenshot({ path: outputPath });
+      process.stdout.write(`${outputPath}\n`);
+      return;
+    }
+
+    throw new Error(`Unknown axe command "${command}".`);
+  } finally {
+    await browser.close();
+  }
+}
+
+await main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[axe] ${message}`);
+  process.exit(1);
+});

package/bin/stick.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { glob } from 'glob';
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  console.log('Usage: stick <pattern|files...>');
+  console.log('');
+  console.log('Runs TypeScript files with Svelte SSR support for visual previews.');
+  console.log('');
+  console.log('Examples:');
+  console.log('  stick my-preview.stick.ts');
+  console.log('  stick "**/*.stick.ts"');
+  process.exit(0);
+}
+
+async function runFile(file) {
+  return new Promise((resolve) => {
+    const child = spawn(
+      'npx',
+      ['tsx', '--loader', '@noego/wood/loader', file],
+      {
+        stdio: 'inherit',
+        shell: true,
+        env: { ...process.env, STICK_CLI: '1' },
+      }
+    );
+
+    child.on('close', (code) => {
+      resolve({ file, code: code ?? 0 });
+    });
+
+    child.on('error', (err) => {
+      console.error(`Error running ${file}:`, err.message);
+      resolve({ file, code: 1 });
+    });
+  });
+}
+
+async function main() {
+  const files = [];
+
+  // Support both shell expansion (multiple args) and glob patterns
+  for (const arg of args) {
+    if (arg.includes('*')) {
+      for await (const file of glob.iterate(arg)) {
+        files.push(file);
+      }
+    } else {
+      files.push(arg);
+    }
+  }
+
+  if (files.length === 0) {
+    console.error(`No files found matching: ${args.join(' ')}`);
+    process.exit(1);
+  }
+
+  // Sort for consistent ordering
+  files.sort();
+
+  const results = [];
+
+  for (const file of files) {
+    if (files.length > 1) {
+      console.log(`\n━━━ ${file} ━━━\n`);
+    }
+    const result = await runFile(file);
+    results.push(result);
+  }
+
+  // Summary if multiple files
+  if (files.length > 1) {
+    const passed = results.filter(r => r.code === 0);
+    const failed = results.filter(r => r.code !== 0);
+
+    console.log('\n━━━ Summary ━━━\n');
+    console.log(`Passed: ${passed.length}/${results.length}`);
+
+    if (failed.length > 0) {
+      console.log('\nFailed:');
+      failed.forEach(r => console.log(`  - ${r.file}`));
+    }
+
+    process.exit(failed.length > 0 ? 1 : 0);
+  } else {
+    process.exit(results[0].code);
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err);
+  process.exit(1);
+});