@maiaos/cli 0.1.0-canary.2

package/dist/command-tree/suggest.js

@@ -0,0 +1,81 @@
+import { findNode, treeNodes } from "./tree.js";
+const PATH_WORD = /^[a-z][a-z0-9-]*$/u;
+const MAXIMUM_SUGGESTIONS = 3;
+const RETIRED_WORDS = new Map([
+    ["add", ["register", "install", "attach"]],
+    ["limit", ["capacity"]],
+    ["recovery", ["doctor"]],
+    ["signin", ["login"]],
+]);
+const stem = (word) => word.replace(/-(?:preview|confirm)$/u, "").replace(/s$/u, "");
+const commonPrefix = (left, right, at = 0) => at < left.length && left[at] === right[at]
+    ? commonPrefix(left, right, at + 1)
+    : at;
+const resembles = (typed, name) => {
+    const [left, right] = [stem(typed), stem(name)];
+    if (left === right)
+        return true;
+    if (name.split("-").some((part) => stem(part) === left))
+        return true;
+    const shared = commonPrefix(left, right);
+    return shared >= 4 && shared >= Math.min(left.length, right.length) - 2;
+};
+const typedWords = (word) => [
+    word,
+    ...(RETIRED_WORDS.get(word) ?? []),
+];
+const matches = (node, word) => typedWords(word).some((typed) => node.path.some((name) => resembles(typed, name)));
+const strength = (node, word) => {
+    const typed = typedWords(word);
+    if (typed.some((each) => stem(each) === stem(node.name)))
+        return 2;
+    return typed.some((each) => resembles(each, node.name)) ? 1 : 0;
+};
+const collapse = (node) => {
+    const [only, ...others] = node.children;
+    return node.forms.length === 0 && only !== undefined && others.length === 0
+        ? collapse(only)
+        : node;
+};
+export const suggestPaths = (tokens) => {
+    const words = tokens.filter((token) => PATH_WORD.test(token));
+    const { consumed } = findNode(tokens);
+    const unknown = tokens[consumed];
+    if (unknown === undefined || !PATH_WORD.test(unknown))
+        return [];
+    const scored = treeNodes()
+        .filter((node) => matches(node, unknown))
+        .map((node) => ({
+        node,
+        score: words.filter((word) => matches(node, word)).length,
+        strength: strength(node, unknown),
+    }));
+    const best = Math.max(0, ...scored.map(({ score }) => score));
+    const top = scored.filter(({ score }) => score === best);
+    const strongest = Math.max(0, ...top.map((entry) => entry.strength));
+    const paths = top
+        .filter((entry) => entry.strength === strongest)
+        .toSorted((left, right) => Number(right.node.forms.length > 0) -
+        Number(left.node.forms.length > 0) ||
+        left.node.path.length - right.node.path.length)
+        .map(({ node }) => `maia ${collapse(node).path.join(" ")}`);
+    return [...new Set(paths)].slice(0, MAXIMUM_SUGGESTIONS);
+};
+export const unknownPathMessage = (tokens) => {
+    const { consumed, node } = findNode(tokens);
+    const unknown = tokens[consumed];
+    const children = node.children.map((child) => child.name).join(", ");
+    if (unknown === undefined)
+        return `'maia ${node.path.join(" ")}' takes a command: ${children}.`;
+    if (unknown.startsWith("-"))
+        return node.path.length === 0
+            ? `Unknown option '${unknown}'.`
+            : `'maia ${node.path.join(" ")}' takes a command: ${children}.`;
+    const suggestions = suggestPaths(tokens);
+    if (suggestions.length > 0)
+        return `Unknown command '${unknown}'. Did you mean ${suggestions.map((path) => `'${path}'`).join(", ")}?`;
+    return node.path.length === 0
+        ? `Unknown command '${unknown}'.`
+        : `Unknown command '${unknown}'; 'maia ${node.path.join(" ")}' takes: ${children}.`;
+};
+//# sourceMappingURL=suggest.js.map

package/dist/command-tree/tree.d.ts

@@ -0,0 +1,34 @@
+import type { RunnerReference, TreeFragment, TreeLeafKind, TreeOperation } from "./row.js";
+export type TreeAvailability = "implemented" | "source_implemented_candidate";
+export type TreeLeafForm = {
+    readonly availability: TreeAvailability;
+    readonly summary: string;
+    readonly usage: string;
+};
+export type TreeNode = {
+    readonly children: readonly TreeNode[];
+    readonly example?: string;
+    readonly forms: readonly TreeLeafForm[];
+    readonly kind?: TreeLeafKind;
+    readonly name: string;
+    readonly node?: true;
+    readonly operations: readonly TreeOperation[];
+    readonly path: readonly string[];
+    readonly remote?: false;
+    readonly run?: RunnerReference;
+    readonly summary: string;
+};
+export declare const TREE_FRAGMENTS: readonly TreeFragment[];
+export declare const TREE_SECTIONS: readonly [readonly ["Start and sign in", readonly ["setup", "login", "status"]], readonly ["Work", readonly ["session", "run", "import"]], readonly ["Resources", readonly ["project", "workspace", "container", "terminal", "execution", "port", "reference"]], readonly ["Accounts and Nodes", readonly ["connection", "integration", "provider", "node"]], readonly ["Safety and audit", readonly ["hold", "receipt", "context"]], readonly ["Clients and local", readonly ["presentation", "mcp", "agent", "help", "version", "doctor", "completion"]]];
+export declare const usagePath: (usage: string) => readonly string[];
+export declare const COMMAND_TREE: TreeNode;
+export declare const commandTree: () => TreeNode;
+export declare const findNode: (tokens: readonly string[]) => {
+    readonly consumed: number;
+    readonly node: TreeNode;
+};
+export declare const treeNodes: (node?: TreeNode) => TreeNode[];
+export declare const isNodeBacked: (node: TreeNode) => boolean;
+export declare const treeUsages: () => string[];
+export declare const createTreeDigest: (usages?: readonly string[]) => string;
+//# sourceMappingURL=tree.d.ts.map

package/dist/command-tree/tree.js

@@ -0,0 +1,124 @@
+import { createHash } from "node:crypto";
+import { CONNECTION_TREE } from "../connection/tree/index.js";
+import { EXECUTION_TREE } from "../execution/tree/index.js";
+import { SAFETY_TREE } from "../hold/tree/index.js";
+import { RUN_TREE } from "../orchestration/tree/index.js";
+import { PROJECT_TREE } from "../project-workspace/tree/index.js";
+import { REFERENCE_TREE } from "../reference/tree/index.js";
+import { NODE_TREE } from "../remote-node/tree/index.js";
+import { SESSION_TREE } from "../session/tree/index.js";
+import { TERMINAL_TREE } from "../terminal/tree/index.js";
+import { LOCAL_TREE } from "./local.js";
+export const TREE_FRAGMENTS = [
+    NODE_TREE,
+    CONNECTION_TREE,
+    SESSION_TREE,
+    RUN_TREE,
+    PROJECT_TREE,
+    REFERENCE_TREE,
+    TERMINAL_TREE,
+    EXECUTION_TREE,
+    SAFETY_TREE,
+    LOCAL_TREE,
+];
+export const TREE_SECTIONS = [
+    ["Start and sign in", ["setup", "login", "status"]],
+    ["Work", ["session", "run", "import"]],
+    [
+        "Resources",
+        [
+            "project",
+            "workspace",
+            "container",
+            "terminal",
+            "execution",
+            "port",
+            "reference",
+        ],
+    ],
+    ["Accounts and Nodes", ["connection", "integration", "provider", "node"]],
+    ["Safety and audit", ["hold", "receipt", "context"]],
+    [
+        "Clients and local",
+        ["presentation", "mcp", "agent", "help", "version", "doctor", "completion"],
+    ],
+];
+const PATH_WORD = /^[a-z][a-z0-9-]*$/u;
+export const usagePath = (usage) => {
+    const words = usage.split(" ");
+    const end = words.findIndex((word) => !PATH_WORD.test(word));
+    return words.slice(0, end === -1 ? words.length : end);
+};
+const nodeAt = (root, path) => path.reduce((parent, name) => {
+    const existing = parent.children.find((child) => child.name === name);
+    if (existing !== undefined)
+        return existing;
+    const created = {
+        children: [],
+        forms: [],
+        name,
+        operations: [],
+        path: [...parent.path, name],
+        summary: "",
+    };
+    parent.children.push(created);
+    return created;
+}, root);
+const addLeaf = (root, row) => {
+    const [usage, availability, operations, summary, extra] = row;
+    const node = nodeAt(root, usagePath(usage));
+    node.forms.push({
+        availability: availability === 0 ? "implemented" : "source_implemented_candidate",
+        summary,
+        usage,
+    });
+    if (node.forms.length > 1)
+        return;
+    node.summary = summary;
+    node.operations = operations === "" ? [] : [operations].flat();
+    node.kind = extra.kind ?? "operation";
+    node.run = extra.run;
+    if (extra.node !== undefined)
+        node.node = extra.node;
+    if (extra.remote !== undefined)
+        node.remote = extra.remote;
+    if (extra.example !== undefined)
+        node.example = extra.example;
+};
+const sectionOrder = TREE_SECTIONS.flatMap(([, names]) => names);
+const buildTree = () => {
+    const root = {
+        children: [],
+        forms: [],
+        name: "maia",
+        operations: [],
+        path: [],
+        summary: "Maia OS command line.",
+    };
+    sectionOrder.forEach((name) => nodeAt(root, [name]));
+    TREE_FRAGMENTS.forEach((fragment) => {
+        fragment.leaves.forEach((row) => {
+            addLeaf(root, row);
+        });
+    });
+    TREE_FRAGMENTS.forEach((fragment) => {
+        fragment.groups.forEach(([path, summary]) => {
+            nodeAt(root, path.split(" ")).summary = summary;
+        });
+    });
+    return root;
+};
+export const COMMAND_TREE = buildTree();
+export const commandTree = () => COMMAND_TREE;
+const descend = (node, tokens, consumed) => {
+    const child = node.children.find((candidate) => candidate.name === tokens[consumed]);
+    return child === undefined
+        ? { consumed, node }
+        : descend(child, tokens, consumed + 1);
+};
+export const findNode = (tokens) => descend(COMMAND_TREE, tokens, 0);
+export const treeNodes = (node = commandTree()) => node.children.flatMap((child) => [child, ...treeNodes(child)]);
+export const isNodeBacked = (node) => node.forms.length > 0 && (node.kind !== "local" || node.node === true);
+export const treeUsages = () => treeNodes().flatMap((node) => node.forms.map((form) => form.usage));
+export const createTreeDigest = (usages = treeUsages()) => `sha256:${createHash("sha256").update(usages.join("\n")).digest("hex")}`;
+//# sourceMappingURL=tree.js.map