fluidcad 0.0.33 → 0.0.34

package/README.md

@@ -216,10 +216,10 @@ See the full list of commands in the [Neovim plugin README](extension/neovim/REA
 <details>
 <summary><strong>Any Other Editor</strong></summary>
 
-Run the FluidCAD server directly:
+From your project directory, run the FluidCAD server directly:
 
 ```bash
-npx fluidcad -w ./my-app
+npx fluidcad serve
 ```
 
 This starts a local server and opens a 3D viewport in your browser. Edit your `.fluid.js` files in any editor -- the viewport updates on save.
@@ -230,6 +230,7 @@ This starts a local server and opens a 3D viewport in your browser. Edit your `.
 |------|-------------|---------|
 | `-w, --workspace <path>` | Path to your project | Current directory |
 | `-p, --port <port>` | Server port | `3100` |
+| `--open` | Open the viewport in your default browser when ready | _off_ |
 
 </details>
 

package/bin/commands/init.js

@@ -0,0 +1,55 @@
+import { writeFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+const INIT_JS = `import { init } from 'fluidcad'\n\nexport default await init()\n`;
+
+const TEST_FLUID_JS = `import { extrude, fillet, rect, shell, sketch } from "fluidcad/core";
+
+sketch("xy", () => {
+    rect(100, 50).radius(10).centered();
+});
+
+const e = extrude(30);
+
+fillet(4, e.startEdges());
+
+shell(-2, e.endFaces());
+`;
+
+const JSCONFIG = JSON.stringify({
+  compilerOptions: {
+    checkJs: true,
+    module: 'node20',
+  },
+}, null, 2) + '\n';
+
+function runInit() {
+  const cwd = process.cwd();
+
+  const initPath = resolve(cwd, 'init.js');
+  if (existsSync(initPath)) {
+    console.error('init.js already exists in this directory.');
+    process.exit(1);
+  }
+
+  writeFileSync(initPath, INIT_JS);
+
+  const testPath = resolve(cwd, 'test.fluid.js');
+  if (!existsSync(testPath)) {
+    writeFileSync(testPath, TEST_FLUID_JS);
+  }
+
+  const jsconfigPath = resolve(cwd, 'jsconfig.json');
+  if (!existsSync(jsconfigPath)) {
+    writeFileSync(jsconfigPath, JSCONFIG);
+  }
+
+  console.log('FluidCAD initialized.');
+}
+
+export function registerInitCommand(program) {
+  program
+    .command('init')
+    .description('Scaffold init.js, test.fluid.js, and jsconfig.json in the current directory')
+    .action(runInit);
+}

package/bin/commands/mcp.js

@@ -0,0 +1,33 @@
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const mcpEntry = resolve(__dirname, '..', '..', 'mcp', 'dist', 'server.js');
+
+async function runMcp() {
+  // stdout is reserved for the MCP protocol. Any incidental console.log from
+  // FluidCAD internals would corrupt the stream — route everything to stderr.
+  console.log = (...args) => console.error(...args);
+  console.info = (...args) => console.error(...args);
+
+  const mod = await import(mcpEntry);
+  if (typeof mod.runStdio !== 'function') {
+    console.error('mcp/dist/server.js does not export runStdio.');
+    process.exit(1);
+  }
+  await mod.runStdio();
+}
+
+export function registerMcpCommand(program) {
+  program
+    .command('mcp')
+    .description('Run the FluidCAD MCP server over stdio (for Claude Desktop, Claude Code, Cursor, ...)')
+    .action(async () => {
+      try {
+        await runMcp();
+      } catch (err) {
+        console.error(err?.stack || err?.message || String(err));
+        process.exit(1);
+      }
+    });
+}

package/bin/commands/serve.js

@@ -0,0 +1,77 @@
+import { fork } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import open from 'open';
+import { createFileWatcher, findFluidFiles } from '../watcher.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const serverEntry = resolve(__dirname, '..', '..', 'server', 'dist', 'index.js');
+
+function runServe(opts) {
+  const workspacePath = resolve(opts.workspace);
+  const port = String(opts.port);
+
+  const server = fork(serverEntry, [], {
+    env: {
+      ...process.env,
+      FLUIDCAD_SERVER_PORT: port,
+      FLUIDCAD_WORKSPACE_PATH: workspacePath,
+    },
+    stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+  });
+
+  server.stdout.on('data', (data) => { process.stdout.write(data); });
+  server.stderr.on('data', (data) => { process.stderr.write(data); });
+
+  let watcher;
+
+  server.on('message', (msg) => {
+    if (msg.type === 'ready') {
+      console.log(`FluidCAD server ready at ${msg.url}`);
+      if (opts.open) {
+        open(msg.url).catch((err) => {
+          console.error(`Failed to open browser: ${err.message}`);
+        });
+      }
+    }
+    if (msg.type === 'init-complete') {
+      if (msg.success) {
+        console.log('FluidCAD initialized successfully.');
+        watcher = createFileWatcher(workspacePath, server);
+
+        const files = findFluidFiles(workspacePath);
+        if (files.length > 0) {
+          server.send({ type: 'process-file', filePath: files[0] });
+        }
+      } else {
+        console.error(`FluidCAD initialization failed: ${msg.error}`);
+        process.exit(1);
+      }
+    }
+  });
+
+  server.on('exit', (code) => {
+    if (watcher) { watcher.close(); }
+    process.exit(code || 0);
+  });
+
+  process.on('SIGINT', () => {
+    if (watcher) { watcher.close(); }
+    server.kill('SIGINT');
+  });
+
+  process.on('SIGTERM', () => {
+    if (watcher) { watcher.close(); }
+    server.kill('SIGTERM');
+  });
+}
+
+export function registerServeCommand(program) {
+  program
+    .command('serve')
+    .description('Start the FluidCAD server and watch .fluid.js files')
+    .option('-w, --workspace <path>', 'workspace directory', process.cwd())
+    .option('-p, --port <port>', 'server port', '3100')
+    .option('--open', 'open the UI in the default browser when ready', false)
+    .action(runServe);
+}

package/bin/fluidcad.js

@@ -1,115 +1,23 @@
 #!/usr/bin/env node
 
-import { fork } from 'child_process';
-import { resolve, dirname } from 'path';
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { parseArgs } from 'util';
-import { writeFileSync, existsSync } from 'fs';
-import { createFileWatcher, findFluidFiles } from './watcher.js';
+import { registerInitCommand } from './commands/init.js';
+import { registerServeCommand } from './commands/serve.js';
+import { registerMcpCommand } from './commands/mcp.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf8'));
 
-const { values, positionals } = parseArgs({
-  options: {
-    port: { type: 'string', short: 'p', default: '3100' },
-    workspace: { type: 'string', short: 'w', default: process.cwd() },
-  },
-  allowPositionals: true,
-});
+const program = new Command()
+  .name('fluidcad')
+  .description('FluidCAD CLI')
+  .version(pkg.version);
 
-if (positionals[0] === 'init') {
-  const cwd = process.cwd();
+registerInitCommand(program);
+registerServeCommand(program);
+registerMcpCommand(program);
 
-  const initPath = resolve(cwd, 'init.js');
-  if (existsSync(initPath)) {
-    console.error('init.js already exists in this directory.');
-    process.exit(1);
-  }
-
-  writeFileSync(initPath, `import { init } from 'fluidcad'\n\nexport default await init()\n`);
-
-  const testPath = resolve(cwd, 'test.fluid.js');
-  if (!existsSync(testPath)) {
-    writeFileSync(testPath, `import { extrude, fillet, rect, shell, sketch } from "fluidcad/core";
-
-sketch("xy", () => {
-    rect(100, 50).radius(10).centered();
-});
-
-const e = extrude(30);
-
-fillet(4, e.startEdges());
-
-shell(-2, e.endFaces());
-`);
-  }
-
-  const jsconfigPath = resolve(cwd, 'jsconfig.json');
-  if (!existsSync(jsconfigPath)) {
-    writeFileSync(jsconfigPath, JSON.stringify({
-      compilerOptions: {
-        checkJs: true,
-        module: 'node20',
-      },
-    }, null, 2) + '\n');
-  }
-
-  console.log('FluidCAD initialized.');
-  process.exit(0);
-}
-
-const serverEntry = resolve(__dirname, '..', 'server', 'dist', 'index.js');
-
-const server = fork(serverEntry, [], {
-  env: {
-    ...process.env,
-    FLUIDCAD_SERVER_PORT: values.port,
-    FLUIDCAD_WORKSPACE_PATH: resolve(values.workspace),
-  },
-  stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-});
-
-server.stdout.on('data', (data) => {
-  process.stdout.write(data);
-});
-
-server.stderr.on('data', (data) => {
-  process.stderr.write(data);
-});
-
-const workspacePath = resolve(values.workspace);
-let watcher;
-
-server.on('message', (msg) => {
-  if (msg.type === 'ready') {
-    console.log(`FluidCAD server ready at ${msg.url}`);
-  }
-  if (msg.type === 'init-complete') {
-    if (msg.success) {
-      console.log('FluidCAD initialized successfully.');
-      watcher = createFileWatcher(workspacePath, server);
-
-      const files = findFluidFiles(workspacePath);
-      if (files.length > 0) {
-        server.send({ type: 'process-file', filePath: files[0] });
-      }
-    } else {
-      console.error(`FluidCAD initialization failed: ${msg.error}`);
-      process.exit(1);
-    }
-  }
-});
-
-server.on('exit', (code) => {
-  process.exit(code || 0);
-});
-
-process.on('SIGINT', () => {
-  if (watcher) { watcher.close(); }
-  server.kill('SIGINT');
-});
-
-process.on('SIGTERM', () => {
-  if (watcher) { watcher.close(); }
-  server.kill('SIGTERM');
-});
+program.parseAsync(process.argv);

package/lib/dist/common/scene-object.d.ts

@@ -2,6 +2,7 @@ import { Shape, ShapeFilter } from "./shape.js";
 import { Face } from "./face.js";
 import { Edge } from "./edge.js";
 import { Matrix4 } from "../math/matrix4.js";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 import { ISceneObject } from "../core/interfaces.js";
 import { FusionScope, OperationMode } from "../features/extrude-options.js";
 import { ShapeType } from "./shape-type.js";
@@ -90,7 +91,7 @@ export declare abstract class SceneObject implements Comparable<SceneObject>, Se
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     clone(): SceneObject[];
-    setTransform(matrix: Matrix4): void;
+    setTransform(matrix: Matrix4 | LazyMatrix): void;
     getTransform(): Matrix4 | null;
     setCloneSource(source: SceneObject): void;
     getCloneSource(): SceneObject | null;

package/lib/dist/common/scene-object.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "crypto";
+import { LazyMatrix } from "../math/lazy-matrix.js";
 export class SceneObject {
     state;
     children = [];
@@ -200,10 +201,10 @@ export class SceneObject {
         return result;
     }
     setTransform(matrix) {
-        this._transform = matrix;
+        this._transform = matrix instanceof LazyMatrix ? matrix : LazyMatrix.of(matrix);
     }
     getTransform() {
-        return this._transform;
+        return this._transform ? this._transform.resolve() : null;
     }
     setCloneSource(source) {
         this._cloneSource = source;

package/lib/dist/core/2d/tarc.d.ts

@@ -1,7 +1,25 @@
 import { Point2DLike } from "../../math/point.js";
 import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
-import { IGeometry, ISceneObject, ITangentArcTwoObjects } from "../interfaces.js";
+import { IGeometry, ISceneObject, ITangentArcToObject, ITangentArcTwoObjects } from "../interfaces.js";
 interface TArcFunction {
+    /**
+     * Draws a tangent arc from the current position using the current tangent
+     * direction, ending tangent to a target line. The radius is solved
+     * automatically; the arc must be tangent to the target but does not need
+     * to touch its finite extent. By default the arc curves to the left of
+     * the start tangent — chain `.flip()` to curve to the right instead.
+     * @param target - The target line (or a qualified line)
+     */
+    (target: ISceneObject | QualifiedSceneObject): ITangentArcToObject;
+    /**
+     * Draws a tangent arc from the current position using the current tangent
+     * direction, with the given radius, ending at the first intersection with
+     * the target geometry along the arc's sweep direction. A negative radius
+     * flips the sweep direction. Supported targets: lines, circles, and arcs.
+     * @param radius - The arc radius. A negative value flips the sweep direction.
+     * @param target - The target geometry to intersect with
+     */
+    (radius: number, target: ISceneObject | QualifiedSceneObject): IGeometry;
     /**
      * Draws a tangent arc with a given radius and end angle.
      * @param radius - The arc radius (defaults to 100). A negative value flips the sweep direction.
@@ -34,7 +52,7 @@ interface TArcFunction {
      */
     (startPoint: Point2DLike, endPoint: Point2DLike, tangent: Point2DLike): IGeometry;
     /**
-     * Draws a tangent arc between two geometry objects.
+     * Draws all possible tangent arcs between two geometry objects.
      * @param c1 - The first geometry object
      * @param c2 - The second geometry object
      * @param radius - The arc radius

package/lib/dist/core/2d/tarc.js

@@ -3,13 +3,37 @@ import { TangentArc } from "../../features/2d/tarc.js";
 import { TangentArcToPoint } from "../../features/2d/tarc-to-point.js";
 import { TangentArcToPointTangent } from "../../features/2d/tarc-to-point-tangent.js";
 import { TangentArcWithTangent } from "../../features/2d/tarc-with-tangent.js";
+import { TangentArcToObject } from "../../features/2d/tarc-to-object.js";
+import { TangentArcRadiusToObject } from "../../features/2d/tarc-radius-to-object.js";
 import { Move } from "../../features/2d/move.js";
 import { normalizePoint2D } from "../../helpers/normalize.js";
 import { registerBuilder } from "../../index.js";
 import { QualifiedSceneObject } from "../../features/2d/constraints/qualified-geometry.js";
 import { TangentArcTwoObjects } from "../../features/2d/tarc-constrained.js";
+import { SceneObject } from "../../common/scene-object.js";
 function build(context) {
     return function tarc() {
+        // tArc(target): single scene-object target, radius solved automatically.
+        // LazyVertex extends SceneObject but represents a point — fall through to the
+        // Point2DLike branch below so tArc(lazyVertex) becomes tArc(endPoint).
+        if (arguments.length === 1 &&
+            ((arguments[0] instanceof SceneObject && !isPoint2DLike(arguments[0])) ||
+                arguments[0] instanceof QualifiedSceneObject)) {
+            const target = QualifiedSceneObject.from(arguments[0]);
+            const arc = new TangentArcToObject(target);
+            context.addSceneObject(arc);
+            return arc;
+        }
+        // tArc(radius, target): explicit radius, end at first intersection with target
+        if (arguments.length === 2 &&
+            typeof arguments[0] === 'number' &&
+            (arguments[1] instanceof SceneObject || arguments[1] instanceof QualifiedSceneObject)) {
+            const radius = arguments[0];
+            const target = QualifiedSceneObject.from(arguments[1]);
+            const arc = new TangentArcRadiusToObject(radius, target);
+            context.addSceneObject(arc);
+            return arc;
+        }
         // tarc(c1, c2, radius): fillet arc tangent to two circles/points
         if ((arguments.length === 3 || arguments.length === 4) && typeof arguments[2] === 'number') {
             const o1 = isPoint2DLike(arguments[0]) ? normalizePoint2D(arguments[0]) : arguments[0];

package/lib/dist/core/interfaces.d.ts

@@ -157,13 +157,27 @@ export interface IArcPoints extends IExtrudableGeometry {
      * Positive = CCW, negative = CW.
      * @param value - The bulge radius.
      */
-    radius(value: number): this;
+    radius(value: number): IArcRadius;
     /**
      * Specifies the circle center point for the arc.
      * Mutually exclusive with `.radius()`.
      * @param value - The center point of the arc's circle.
      */
-    center(value: Point2DLike): this;
+    center(value: Point2DLike): IArcCenter;
+}
+export interface IArcRadius extends IExtrudableGeometry {
+    /**
+     * Switches to the major arc (> 180°).
+     * By default, `.radius()` produces the minor arc (< 180°);
+     * `.major()` switches to the complementary major arc on the same circle.
+     */
+    major(): this;
+}
+export interface IArcCenter extends IExtrudableGeometry {
+    /**
+     * Sweeps the arc clockwise from start to end instead of the default counter-clockwise.
+     */
+    cw(): this;
 }
 export interface IArcAngles extends IExtrudableGeometry {
     /**
@@ -298,6 +312,14 @@ export interface ITwoObjectsTangentLine extends IGeometry {
      */
     end(index?: number): LazyVertex;
 }
+export interface ITangentArcToObject extends IGeometry {
+    /**
+     * Flips the arc to the opposite side of the start tangent. By default,
+     * the arc curves to the left of the current tangent direction;
+     * `.flip()` switches it to the right.
+     */
+    flip(): this;
+}
 export interface ITangentArcTwoObjects extends IGeometry {
     /**
      * Returns the start vertex of the tangent arc.
@@ -771,6 +793,7 @@ export interface IRib extends IBooleanOperation {
      */
     extend(): this;
 }
+export type ShellJoinType = 'arc' | 'intersection' | 'tangent';
 export interface IShell extends ISceneObject {
     /**
      * Selects the inner wall faces created by the shell operation (from thickness removal).
@@ -783,4 +806,10 @@ export interface IShell extends ISceneObject {
      * @param args - Numeric indices or {@link EdgeFilterBuilder} instances to filter the selection.
      */
     internalEdges(...args: (number | EdgeFilterBuilder)[]): ISceneObject;
+    /**
+     * Sets the join type used at inner-wall corners.
+     * @param type - `'arc'` (default) for rounded blends, `'intersection'` for sharp corners,
+     *   or `'tangent'` for tangent-continuous blends.
+     */
+    join(type: ShellJoinType): this;
 }