asljs-diagram-cli 0.0.0-stage → 0.1.1

package/LICENSE.md

@@ -0,0 +1,51 @@
+# Permissive No-Derivatives License 1.0
+
+Copyright (c) 2026 Alexandrite Software Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software (the "Software") to:
+
+1. Use the Software for any purpose, including commercial purposes.
+2. Copy and redistribute the Software, including as part of another application,
+   library, or package.
+3. Modify the Software for private or internal use.
+
+Subject to the following conditions:
+
+## 1. No Distribution of Modified Versions
+
+Modified versions of the Software, or substantial portions thereof, must not be
+distributed without prior written permission from the copyright holder.
+
+Routine build transformations, including minification, transpilation, and
+bundling, are permitted for distribution, provided they do not intentionally
+alter the Software's functionality.
+
+## 2. Licence and Copyright Preservation
+
+All distributed copies of the Software must retain this copyright notice and
+licence.
+
+The Software itself, including copies incorporated into other applications,
+libraries, or packages, remains subject to this licence.
+
+The Software must not be sublicensed or redistributed under a different licence.
+
+## 3. Use in Other Software
+
+Applications and libraries that merely use, import, link to, or bundle the
+Software are not considered modified versions of the Software and may be
+distributed under any licence.
+
+Such use, incorporation, or bundling does not grant permission to relicense the
+Software or distribute modified versions of it.
+
+### 4. No Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR
+OTHER LIABILITY ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR ITS
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,85 @@
-# Temporary Holding Version
+# diagram-cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> Part of [Alexandrite Software Library][#1] - a set of high-quality and
+> performant JavaScript libraries for everyday use.
+
+## Overview
+
+`asljs-diagram-cli` is the `diagram` command. `diagram view <path>` reads a
+diagram file, a graph of nodes and links or a diagram of visual elements, and
+shows it in the browser with [asljs-ui-diagram][LIB]: pan, zoom, select, move
+and resize, and for a graph, add, link and delete nodes.
+
+```bash
+diagram view build/ts-classes.diagram.json
+```
+
+```text
+Showing build/ts-classes.diagram.json at http://127.0.0.1:52144/
+Press Ctrl+C to stop.
+```
+
+## Scope
+
+- **Files.** A JSON document in the `asljs-ui-diagram` format: `"type": "graph"`
+  with `nodes` and `links`, or `"type": "diagram"` with `elements`. The file is
+  checked before anything is served, and an error names the invalid value.
+- **Local and in memory.** The command serves the page on `127.0.0.1` and opens
+  the default browser. Edits stay in the page; the file is read again on each
+  reload and never written.
+- **Generated diagrams.** `toolkit build-ts-files-diagram` writes the import
+  graph of TypeScript sources in this format, and `toolkit
+  build-ts-class-diagram` their class diagram.
+
+## Installation
+
+```bash
+npm install --global asljs-diagram-cli
+```
+
+NPM Package: [asljs-diagram-cli][NPM]
+
+## Usage
+
+```bash
+# A free port, and the browser opens
+diagram view graph.json
+
+# A fixed port, without opening the browser
+diagram view graph.json --port 8080 --no-open
+```
+
+A minimal graph file:
+
+```json
+{ "type": "graph",
+  "nodes": [ { "id": "a", "label": "Start", "x": 0, "y": 0 },
+             { "id": "b", "label": "End", "x": 220, "y": 0 } ],
+  "links": [ { "from": "a", "to": "b" } ] }
+```
+
+## Further reading
+
+- [diagram view][DOC] - the options, what the page does, and the errors.
+- [Diagram][FMT] - the document format, in `asljs-ui-diagram`.
+
+Questions and bugs: [asljs/issues][ISS].
+
+## Related packages
+
+- [ui-diagram][LIB] - the diagram component and models the page uses.
+- [toolkit][TLK] - `build-ts-files-diagram` and `build-ts-class-diagram` turn
+  `.structure.json` files into diagram files.
+
+## License
+
+MIT License. See [LICENSE][LIC] for details.
+
+[#1]: https://github.com/AlexandriteSoftware/asljs
+[DOC]: <docs/Diagram CLI.md>
+[FMT]: ../../ui/diagram/docs/Diagram.md#documents
+[ISS]: https://github.com/AlexandriteSoftware/asljs/issues
+[LIB]: ../../ui/diagram/README.md
+[LIC]: LICENSE.md
+[NPM]: https://www.npmjs.com/package/asljs-diagram-cli
+[TLK]: ../toolkit/README.md

package/bin/diagram.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runCli }
+  from '../dist/cli.js';
+
+process.exitCode =
+  await runCli(
+    process.argv.slice(2));

package/dist/cli.d.ts

@@ -0,0 +1,26 @@
+import { type CommandIo } from 'asljs-appbase';
+import { type Viewer } from './server.js';
+/**
+ * The configuration file, looked for in the current directory and its
+ * parents.
+ */
+export declare const CONFIG_FILE = "diagram.json";
+/**
+ * What the command runs with: the folder `diagram.json` is looked for from,
+ * the environment, the output, and how it opens and waits; replaced in tests.
+ */
+export interface CliIo extends CommandIo {
+    /** Opens the viewer's address; the default opens the browser. */
+    open?: (url: string) => void;
+    /**
+     * Resolves when the viewer should stop; the default waits for Ctrl+C or
+     * SIGTERM.
+     */
+    untilStopped?: (viewer: Viewer) => Promise<void>;
+}
+/**
+ * Runs the `diagram` command line, with a logger provider made from
+ * `--loglevel`, `--logfile`, `--logformat`, the `DIAGRAM_LOG_` variables and
+ * `diagram.json`, and returns the exit code.
+ */
+export declare function runCli(args: string[], io?: CliIo): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,80 @@
+import { commandLine, configBoolean, configPort, configString, loadConfig, packageVersion, parsePort, runMain } from 'asljs-appbase';
+import { Command } from 'commander';
+import { openInBrowser } from './open.js';
+import { startViewer } from './server.js';
+/**
+ * The configuration file, looked for in the current directory and its
+ * parents.
+ */
+export const CONFIG_FILE = 'diagram.json';
+/**
+ * Runs the `diagram` command line, with a logger provider made from
+ * `--loglevel`, `--logfile`, `--logformat`, the `DIAGRAM_LOG_` variables and
+ * `diagram.json`, and returns the exit code.
+ */
+export async function runCli(args, io = { cwd: process.cwd(),
+    env: process.env,
+    stdout: process.stdout,
+    stderr: process.stderr }) {
+    return await runMain(args, io, { prefix: 'DIAGRAM_LOG_',
+        configFile: CONFIG_FILE }, async (loggerProvider) => {
+        const cli = createCli(io, loggerProvider);
+        if (args.length === 0) {
+            cli.outputHelp();
+            return 0;
+        }
+        await cli.parseAsync(args, { from: 'user' });
+        return 0;
+    });
+}
+function createCli(io, loggerProvider) {
+    const cli = commandLine(new Command('diagram'), io);
+    cli
+        .description('Shows diagram files in the browser.')
+        .helpCommand(false);
+    cli.command('view')
+        .description('Serve a diagram file, a graph or a diagram of visual elements, and open it in the browser.')
+        .argument('<path>', 'the diagram JSON file')
+        .option('--port <port>', 'the port to listen on; 0, the default, picks a free one')
+        .option('--host <host>', 'the address to listen on; 127.0.0.1 by default')
+        .option('--no-open', 'do not open the browser')
+        .action(async (file, options, command) => {
+        const config = await loadConfig(io.cwd, CONFIG_FILE);
+        const port = parsePort(options.port)
+            ?? configPort(config)
+            ?? 0;
+        const host = options.host
+            ?? configString(config, 'host')
+            ?? '127.0.0.1';
+        const open = command.getOptionValueSource('open') === 'cli'
+            ? options.open
+            : configBoolean(config, 'open')
+                ?? true;
+        const viewer = await startViewer({ file,
+            port,
+            host,
+            logger: loggerProvider.getLogger('diagram') });
+        io.stdout.write(`Showing ${file} at ${viewer.url}\nPress Ctrl+C to stop.\n`);
+        if (open) {
+            (io.open ?? openInBrowser)(viewer.url);
+        }
+        try {
+            await (io.untilStopped ?? untilSignal)(viewer);
+        }
+        finally {
+            await viewer.close();
+        }
+    });
+    cli.command('version')
+        .description('Print the version.')
+        .action(() => {
+        io.stdout.write(`${packageVersion(import.meta.url)}\n`);
+    });
+    return cli;
+}
+function untilSignal() {
+    return new Promise((resolve) => {
+        process.once('SIGINT', () => resolve());
+        process.once('SIGTERM', () => resolve());
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { CONFIG_FILE, runCli } from './cli.js';
+export type { CliIo } from './cli.js';
+export { createImportMap, findBrowserModules } from 'asljs-appbase';
+export type { BrowserModule } from 'asljs-appbase';
+export { readDocument, startViewer } from './server.js';
+export type { Viewer, ViewerOptions } from './server.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { CONFIG_FILE, runCli } from './cli.js';
+export { createImportMap, findBrowserModules } from 'asljs-appbase';
+export { readDocument, startViewer } from './server.js';

package/dist/open.d.ts

@@ -0,0 +1,2 @@
+/** Opens `url` in the default browser, without waiting for it. */
+export declare function openInBrowser(url: string, platform?: NodeJS.Platform): void;

package/dist/open.js

@@ -0,0 +1,20 @@
+import { spawn } from 'node:child_process';
+/** Opens `url` in the default browser, without waiting for it. */
+export function openInBrowser(url, platform = process.platform) {
+    const [command, args] = platform === 'win32'
+        ? ['cmd',
+            ['/c',
+                'start',
+                '""',
+                url]]
+        : platform === 'darwin'
+            ? ['open',
+                [url]]
+            : ['xdg-open',
+                [url]];
+    const child = spawn(command, args, { detached: true,
+        stdio: 'ignore',
+        windowsVerbatimArguments: platform === 'win32' });
+    child.on('error', () => { });
+    child.unref();
+}

package/dist/page.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The viewer page: a toolbar, the diagram and a status line. It loads the
+ * document from `/document`, creates its model, and fits it on first show. For
+ * a graph, the toolbar adds, links and deletes nodes.
+ */
+export declare function renderPage(title: string, importMap: object): string;

package/dist/page.js

@@ -0,0 +1,161 @@
+import { escapeHtml, page, scriptJson } from 'asljs-appbase';
+/**
+ * The viewer page: a toolbar, the diagram and a status line. It loads the
+ * document from `/document`, creates its model, and fits it on first show. For
+ * a graph, the toolbar adds, links and deletes nodes.
+ */
+export function renderPage(title, importMap) {
+    // The import map goes first in the body, before the module script.
+    return page(title, `<script type="importmap">${scriptJson(importMap)}</script>
+<header>
+  <h1>${escapeHtml(title)}</h1>
+  <asljs-diagram-zoom id="zoom"></asljs-diagram-zoom>
+  <asljs-diagram-search id="search"></asljs-diagram-search>
+  <span class="graph-only" hidden>
+    <button type="button" id="add-node">Add node</button>
+    <button type="button" id="add-link" title="Link the two selected nodes, first to second">Link</button>
+  </span>
+  <button type="button" id="delete" title="Delete the selection (Delete key)">Delete</button>
+</header>
+<asljs-diagram id="diagram"></asljs-diagram>
+<footer>
+  <span id="status"></span>
+  <span id="error"></span>
+</footer>
+<script type="module">
+import { createModelFromDocument,
+         isNode,
+         parseDiagramDocument } from 'asljs-ui-diagram';
+
+const diagram = document.querySelector('#diagram');
+const status = document.querySelector('#status');
+const error = document.querySelector('#error');
+
+try {
+  const response = await fetch('document');
+
+  if (!response.ok) {
+    throw new Error((await response.json()).error);
+  }
+
+  const data = parseDiagramDocument(await response.json());
+  const model = createModelFromDocument(data);
+
+  diagram.model = model;
+  document.querySelector('#zoom').viewport = model.viewport;
+  document.querySelector('#search').model = model;
+  window.diagramModel = model;
+
+  const isGraph = data.type === 'graph';
+
+  for (const element of document.querySelectorAll('.graph-only')) {
+    element.hidden = !isGraph;
+  }
+
+  const showStatus = () =>
+  {
+    const elements = model.diagram.elements;
+    const nodes = elements.filter(isNode).length;
+
+    status.textContent =
+      (isGraph
+        ? nodes + ' nodes, ' + (elements.length - nodes) + ' links'
+        : elements.length + ' elements')
+      + (model.selection.length > 0
+        ? '; selected: ' + model.selection.join(', ')
+        : '');
+  };
+
+  model.on('change', showStatus);
+  model.diagram.elements.on('change', showStatus);
+  showStatus();
+
+  document.querySelector('#delete').addEventListener('click', () =>
+    model.deleteElements([ ...model.selection ]));
+
+  document.querySelector('#add-node').addEventListener('click', () =>
+  {
+    const viewport = model.viewport;
+    let index = 1;
+
+    while (model.find('node-' + index)) {
+      index++;
+    }
+
+    const id = 'node-' + index;
+
+    model.addNode(
+      { id,
+        x: (viewport.width / 2 - viewport.x) / viewport.zoom - 60,
+        y: (viewport.height / 2 - viewport.y) / viewport.zoom - 24 });
+
+    model.select([ id ]);
+  });
+
+  document.querySelector('#add-link').addEventListener('click', () =>
+  {
+    const ids = model.selection.filter(id => isNode(model.find(id)));
+
+    if (ids.length !== 2) {
+      error.textContent = 'Select two nodes to link, the first one first.';
+      return;
+    }
+
+    error.textContent = '';
+    model.select([ model.addLink({ from: ids[0], to: ids[1] }) ]);
+  });
+
+  if (!data.viewport) {
+    requestAnimationFrame(() => model.viewport.fit());
+  }
+} catch (failure) {
+  error.textContent = String(failure?.message ?? failure);
+}
+</script>`, `html, body { height: 100%; margin: 0; }
+body {
+  max-width: none;
+  padding: 0;
+  line-height: normal;
+  display: grid;
+  grid-template-rows: auto 1fr auto;
+  font: 14px system-ui, sans-serif;
+  color: #1f2937;
+}
+header, footer {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  align-items: center;
+  padding: 6px 12px;
+  background: #f3f4f6;
+}
+header h1 { font-size: 15px; margin: 0 8px 0 0; }
+asljs-diagram {
+  min-height: 0;
+  background: #ffffff;
+  border-block: 1px solid #d1d5db;
+  outline: none;
+}
+.asljs-diagram-zoom { display: flex; gap: 4px; align-items: center; }
+.zoom-level { min-width: 4ch; text-align: right; }
+.asljs-select-lookup { position: relative; display: inline-block; }
+.asljs-select-lookup [data-role="menu"] {
+  position: absolute;
+  z-index: 10;
+  top: 100%;
+  left: 0;
+  min-width: 240px;
+  padding: 4px;
+  background: #ffffff;
+  border: 1px solid #d1d5db;
+  box-shadow: 0 4px 12px rgb(0 0 0 / 0.12);
+}
+.asljs-select-lookup [data-role="menu"][hidden] { display: none; }
+.asljs-select-lookup [data-role="filter"] { box-sizing: border-box; width: 100%; }
+.asljs-select-lookup [data-role="results"] { list-style: none; margin: 4px 0 0; padding: 0; }
+.asljs-select-lookup-item { display: block; padding: 2px 6px; color: inherit; text-decoration: none; }
+.asljs-select-lookup-item:hover, .asljs-select-lookup-active { background: #e5edff; }
+.asljs-select-lookup-hint { color: #6b7280; }
+.graph-only[hidden] { display: none; }
+#error { color: #b91c1c; white-space: pre-wrap; }`);
+}

package/dist/server.d.ts

@@ -0,0 +1,26 @@
+import { type BrowserModule, type ListenOptions } from 'asljs-appbase';
+export interface ViewerOptions {
+    /** The diagram file to show. */
+    file: string;
+    /** Default 0: any free port. */
+    port?: number;
+    /** Default `127.0.0.1`. */
+    host?: string;
+    /** The packages the page loads; found from `asljs-ui-diagram` by default. */
+    modules?: BrowserModule[];
+    /** Where the server logs; nothing is logged by default. */
+    logger?: ListenOptions['logger'];
+}
+export interface Viewer {
+    url: string;
+    close(): Promise<void>;
+}
+export { MODULES_PREFIX } from 'asljs-appbase';
+/**
+ * Reads and checks the diagram file, then serves the viewer page, the file as
+ * `/document`, and the packages the page imports. The file is read again on
+ * every request for it, so a reload shows its current content.
+ */
+export declare function startViewer(options: ViewerOptions): Promise<Viewer>;
+/** Reads a diagram file and checks it; the error names the file. */
+export declare function readDocument(file: string): Promise<unknown>;

package/dist/server.js

@@ -0,0 +1,63 @@
+import { createHandler, createImportMap, findBrowserModules, jsonReply, MODULES_PREFIX, serve, serverUrl } from 'asljs-appbase';
+import { parseDiagramDocument } from 'asljs-ui-diagram';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { renderPage } from './page.js';
+export { MODULES_PREFIX } from 'asljs-appbase';
+/**
+ * Reads and checks the diagram file, then serves the viewer page, the file as
+ * `/document`, and the packages the page imports. The file is read again on
+ * every request for it, so a reload shows its current content.
+ */
+export async function startViewer(options) {
+    const file = path.resolve(options.file);
+    await readDocument(file);
+    const modules = options.modules
+        ?? findBrowserModules('asljs-ui-diagram', path.dirname(fileURLToPath(import.meta.url)));
+    const page = renderPage(path.basename(file), createImportMap(modules, MODULES_PREFIX));
+    // Nothing but the page, the document and the scripts of the packages.
+    const server = await serve(createHandler({ folder: path.dirname(file),
+        index: async () => page,
+        json: { '/document': async () => {
+                try {
+                    return await readDocument(file);
+                }
+                catch (error) {
+                    return jsonReply(422, { error: error.message });
+                }
+            } },
+        modules,
+        methods: ['GET',
+            'HEAD'],
+        moduleTypes: ['.js',
+            '.mjs',
+            '.map'],
+        allow: () => false }), { port: options.port ?? 0,
+        host: options.host,
+        logger: options.logger });
+    return { url: serverUrl(server),
+        close: () => new Promise((resolve, reject) => {
+            server.closeAllConnections();
+            server.close(error => error
+                ? reject(error)
+                : resolve());
+        }) };
+}
+/** Reads a diagram file and checks it; the error names the file. */
+export async function readDocument(file) {
+    let text;
+    try {
+        text =
+            await readFile(file, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Cannot read ${file}: ${error.message}`);
+    }
+    try {
+        return parseDiagramDocument(JSON.parse(text));
+    }
+    catch (error) {
+        throw new Error(`${file}: ${error.message}`);
+    }
+}

package/docs/Diagram CLI.md

@@ -0,0 +1,78 @@
+# Diagram CLI
+
+## Purpose
+
+What the `diagram` command does: `diagram view`, its options, the page it
+serves, and its errors.
+
+## Logging
+
+Every command also takes `--loglevel <level>`, `--logfile <target>` and
+`--logformat <format>`, or `DIAGRAM_LOG_LEVEL`, `DIAGRAM_LOG_FILE` and
+`DIAGRAM_LOG_FORMAT`, or `logLevel`, `logFile` and `logFormat` of the nearest
+`diagram.json`, in that order. Nothing is logged without them. At `information`
+the log has the address the server listens on, at `trace` each request, and at
+`error` a request that failed.
+
+## diagram view
+
+```text
+diagram view <path> [--port <port>] [--host <host>] [--no-open]
+```
+
+- `<path>` - the diagram file, JSON in the `asljs-ui-diagram` document format.
+- `--port` - the port to listen on; 0, the default, picks a free one.
+- `--host` - the address to listen on, `127.0.0.1` by default.
+- `--no-open` - print the address without opening the browser.
+
+The options can also be set in `diagram.json`, the nearest one in the current
+directory or a parent, as the [configuration][CFG] describes:
+
+- `host` - a string, for `--host`.
+- `port` - an integer from 0 to 65535, for `--port`.
+- `open` - `true` or `false`; `false` is `--no-open`.
+
+An option beats the key: `--no-open` keeps the browser closed with `"open":
+true`. A value of the wrong type ends the command with exit code 1 and a message
+naming the file and the key, such as `diagram.json: "port" must be a port
+number.`
+
+The command reads and checks the file first. A file that cannot be read, is not
+JSON, or does not match the format ends the command with exit code 1 and a
+message naming the file and the first invalid value, such as `graph.json:
+nodes[2].x: expected a number`, before anything is served.
+
+It then serves, until Ctrl+C or SIGTERM:
+
+- `/` - the page.
+- `/document` - the file, read and checked again on every request, so reloading
+  the page shows the file's current content. A file that has become invalid is
+  answered with status 422 and `{ "error": <the message> }`.
+- `/modules/<package>/<path>` - the JavaScript of `asljs-ui-diagram` and the
+  packages it depends on, `asljs-ui-select-lookup` and lit among them, found the
+  way Node finds them from the installed `asljs-ui-diagram`. The page loads them
+  through an import map. Only `.js`, `.mjs` and `.map` files inside a package's
+  folder are served.
+
+Anything else is a 404, and a method other than `GET` and `HEAD` a 405.
+
+## The page
+
+The page shows the file name, the zoom control, the diagram and a status line
+with the number of nodes and links, or of elements, and the selection.
+
+- Without a `viewport` in the file, the diagram is fitted to the window when it
+  first shows.
+- The wheel zooms, dragging the background pans, pressing an element selects it,
+  dragging moves the selection, the corner handles resize, and Delete or the
+  Delete button deletes the selection with its links.
+- For a graph, Add node adds a node in the middle of the window and selects it,
+  and Link links the two selected nodes, from the one selected first.
+
+Edits change the page's model only; nothing is written to the file.
+
+## diagram version
+
+Prints the version of `asljs-diagram-cli`.
+
+[CFG]: ../../../docs/Configuration.md

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "asljs-diagram-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "The diagram command: shows a diagram file, such as a graph, in the browser with asljs-diagram.",
+  "type": "module",
+  "asljs": {
+    "type": "app"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "bin/**",
+    "docs/**",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "bin": {
+    "diagram": "bin/diagram.js"
+  },
+  "scripts": {
+    "flint": "toolkit flint",
+    "clean": "toolkit clean",
+    "build": "npm run codegen --if-present && tsc -p tsconfig.build.json",
+    "build:dist": "npm run codegen --if-present && tsc -p tsconfig.dist.json",
+    "typecheck": "npm run codegen --if-present && tsc -p tsconfig.build.json --noEmit",
+    "guard:clean-git": "toolkit ensure-clean-working-directory",
+    "prepack": "npm run clean && npm run build:dist && npm run build && npm run test && npm run guard:clean-git",
+    "postpublish": "toolkit tag-release-revision",
+    "test": "node --test --enable-source-maps \"build/**/*.test.js\"",
+    "test:watch": "node --watch --test \"build/**/*.test.js\"",
+    "release:patch": "toolkit release-patch",
+    "all": "npm run clean && npm run build:dist && npm run flint && npm run typecheck && npm run build && npm run test"
+  },
+  "keywords": [
+    "diagram",
+    "graph",
+    "viewer",
+    "cli"
+  ],
+  "homepage": "https://github.com/AlexandriteSoftware/asljs#readme",
+  "bugs": {
+    "url": "https://github.com/AlexandriteSoftware/asljs/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AlexandriteSoftware/asljs.git"
+  },
+  "author": "\"Alex Netkachov\" <alex.netkachov@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "asljs-logging": "^0.1.2",
+    "asljs-appbase": "^0.1.3",
+    "asljs-ui-diagram": "^0.1.1",
+    "commander": "^15.0.0"
+  },
+  "devDependencies": {
+    "asljs-testing": "^0.1.0",
+    "asljs-tmpdir": "^0.1.13",
+    "asljs-toolkit": "^0.1.0"
+  }
+}