lineadraw 0.10.0 → 0.11.0

package/README.md

@@ -59,9 +59,13 @@ await doc.exportPdf("plan.pdf");
   its objects; an object's own `opacity` overrides it. Paints across canvas,
   SVG, and PDF; DXF/DWG export drops it (no direct mapping).
 - **Annotation scale is per-object**: for a 1:N drawing set the top-level
-  `scale: N` on text, dimensions, and hatches, keeping `textHeight` at
-  paper size (2.5 body / 3.5 / 5 titles). `scale` is NOT a `styleOverride`
-  key; `add`/`update` reject it there.
+  `scale: N` on text, dimensions, and hatches, keeping the text height
+  at paper size (2.5 body / 3.5 / 5 titles). `scale` is NOT a
+  `styleOverride` key; `add`/`update` reject it there.
+- **One shape per field.** Style keys of a text, table or dimension
+  (`textHeight`, `font`, `bold`, `arrowSize`, …) live in `styleOverride`
+  (or a named style via `styleId`), never at the top level; a hidden layer
+  is `visible: false`. Unknown fields throw, naming where they belong.
 - **Reads are detached snapshots**: `doc.document`, `doc.objects`,
   `getObject`, `listObjects()` return deep clones — mutating them does nothing.
 - **New documents are layout-less**; `exportPdf` of a layout-less document
@@ -146,7 +150,10 @@ Full parameter docs are in the bundled `dist/sdk.d.ts` JSDoc.
 
 `line` (a, b) · `polyline` (points with optional bulge, closed) · `circle` ·
 `arc` (CCW start→end) · `ellipse` (center, majorAxis vector, ratio) ·
-`point` (p) · `hatch` (loops — outer + holes, even-odd; fill solid/pattern/lines) ·
+`point` (p) · `hatch` (loops — outer + holes, even-odd; each loop a closed
+chain of `edges`: `line`, `arc`, `ellipse` or `spline`, with the fields of that
+object type — a circle, ellipse or closed spline is one edge; `hatchLoop(points)`
+builds a polygon / bulged loop; fill solid/pattern/lines) ·
 `text` (position, content; **default alignment center/center**; optional
 leaderLines with the arrowhead at index 0) · `dimension` (linear/angular/
 radial/diameter; linear: `offset` is the signed distance of the dimension
@@ -327,7 +334,7 @@ stay holes:
 ```ts
 const solid = union(...walls.map(wallRect)); // overlapping walls → clean outlines
 return [
-  { type: "hatch", loops: solid.map((points) => ({ points })),
+  { type: "hatch", loops: solid.map(hatchLoop), // a ring → line edges
     fill: { kind: "pattern", name: "ANSI31", angle: 0, scale: 20 } },
   ...solid.map((points) => ({ type: "polyline", points, closed: true })),
 ];
@@ -509,8 +516,9 @@ the file.
 lineadraw status     App version, port, the open drawings: id, name, path, kind, dirty
 lineadraw open <file.linea>            Open a file in a new window
 lineadraw close [--editor <x>] [--discard]
-lineadraw call <operation> ['<json>'] [--editor <x>]   Run one linea_* operation
-lineadraw tools      The operations the bridge offers
+lineadraw call <operation> ['<json>' | @file.json | -] [--editor <x>]   Run one linea_* operation
+lineadraw tools [<operation>]   The operations the bridge offers, or one's argument schema
+lineadraw --version
 ```
 
 These commands talk to the running Linea desktop app on `127.0.0.1:7431`
@@ -524,6 +532,9 @@ SDK's [`connectEditors()`](#running-editors-the-desktop-bridge).
 npx lineadraw call linea_add_objects '{"objects":[{"type":"circle","center":[0,0],"radius":500}]}'
 ```
 
+The arguments can also come from a file (`@args.json`) or stdin (`-`),
+which spares quoting JSON in PowerShell or cmd.
+
 ## Ecosystem
 
 - [Linea](https://lineadraw.com) — the CAD editor, on the desktop and on

package/bin/lineadraw.mjs

@@ -12,6 +12,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { isDeepStrictEqual } from "node:util";
 import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import {
   buildManifest,
   manifestJson,
@@ -35,12 +36,42 @@ Running editors (the Linea desktop app on 127.0.0.1:7431):
   status                                app version, port, the open drawings (id, name, path, kind, dirty)
   open <file.linea>                     open a file in a window of its own (returns its editor)
   close [--editor <x>] [--discard]      close an editor like its window's x
-  call <operation> ['<json>'] [--editor <x>]
-                                        run one linea_* operation (see tools)
-  tools                                 the operations the bridge offers
+  call <operation> ['<json>' | @file.json | -] [--editor <x>]
+                                        run one linea_* operation (see tools);
+                                        its arguments as JSON text, a file, or stdin
+  tools [<operation>]                   the operations the bridge offers, or
+                                        one operation's argument schema
 
 The desktop's bridge.json (port, agent token) is read automatically;
-LINEA_BRIDGE_TOKEN or --token override the token, --port the port.`;
+LINEA_BRIDGE_TOKEN or --token override the token, --port the port.
+
+  --version  the lineadraw version     --help  this text`;
+
+const VERSION = JSON.parse(
+  readFileSync(
+    join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"),
+    "utf8",
+  ),
+).version;
+
+/** `call`'s arguments: JSON text, `@file.json`, or `-` for stdin (quoting
+ * JSON on a Windows command line is a fight best not picked). */
+const readCallArgs = (spec) => {
+  if (spec === undefined) return {};
+  const text =
+    spec === "-"
+      ? readFileSync(0, "utf8")
+      : spec.startsWith("@")
+        ? readFileSync(resolve(spec.slice(1)), "utf8")
+        : spec;
+  try {
+    return JSON.parse(text);
+  } catch (e) {
+    throw new Error(
+      `call: the arguments are not valid JSON (${e instanceof Error ? e.message : e})`,
+    );
+  }
+};
 
 const args = process.argv.slice(2);
 const command = args[0];
@@ -90,12 +121,20 @@ const bridgeCommand = async (cmd, positional, flags) => {
       const [operation, json] = positional;
       if (!operation)
         throw new Error("call needs an operation name (see `lineadraw tools`)");
-      return b.call(operation, json === undefined ? {} : JSON.parse(json), {
-        editor,
-      });
+      return b.call(operation, readCallArgs(json), { editor });
+    }
+    case "tools": {
+      const tools = await b.tools();
+      const wanted = positional[0];
+      if (wanted === undefined)
+        return tools.map(({ name, description }) => ({ name, description }));
+      const tool = tools.find((t) => t.name === wanted);
+      if (!tool)
+        throw new Error(
+          `Unknown operation "${wanted}". \`lineadraw tools\` lists them.`,
+        );
+      return tool;
     }
-    case "tools":
-      return b.tools();
     default:
       throw new Error(`Unknown command: ${cmd}\n\n${USAGE}`);
   }
@@ -184,8 +223,19 @@ switch (command) {
     }
     break;
   }
+  case "--version":
+  case "-v":
+    console.log(VERSION);
+    break;
+  case "--help":
+  case "-h":
+  case "help":
+    console.log(USAGE);
+    break;
   default: {
-    if (!BRIDGE_COMMANDS.includes(command)) fail(USAGE);
+    if (command === undefined) fail(USAGE);
+    if (!BRIDGE_COMMANDS.includes(command))
+      fail(`Unknown command "${command}".\n\n${USAGE}`);
     const { positional, flags } = parseArgs(args.slice(1));
     try {
       const result = await bridgeCommand(command, positional, flags);

package/dist/bridge.d.ts

@@ -78,6 +78,7 @@ interface LineaBridge {
     tools(): Promise<{
         name: string;
         description?: string;
+        inputSchema?: unknown;
     }[]>;
     /** Open a `.linea` file in a window of its own (an absolute path, or one
      * relative to the current directory); resolves once it has loaded. */

package/dist/bridge.js

@@ -4,7 +4,7 @@ import {
   bridgeFilePath,
   connectEditors,
   createBridge
-} from "./chunk-L2CWZAKW.js";
+} from "./chunk-RNA2RDGL.js";
 import "./chunk-PZ5AY32C.js";
 export {
   BridgeError,