@lotics/cli 0.86.1 → 0.87.0

package/dist/package_commands.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/package_commands.test.js

@@ -1,309 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import fs from "node:fs";
-import path from "node:path";
-import { tmpdir } from "node:os";
-import { parseResolveFlags, parseBindToFlags, parseRenameFlags, readLocalAppManifest, formatExtractReport, appRelease, packageUpgradeByPackageId, } from "./package_commands.js";
-import { parseArgs } from "./args.js";
-describe("parseRenameFlags", () => {
-    it("parses old=new pairs", () => {
-        expect(parseRenameFlags(["item=deal", "don_hang=orders"])).toEqual([
-            { from: "item", to: "deal" },
-            { from: "don_hang", to: "orders" },
-        ]);
-        expect(parseRenameFlags(["e.f=name"])).toEqual([{ from: "e.f", to: "name" }]);
-        expect(parseRenameFlags([])).toEqual([]);
-    });
-    it("rejects a malformed rename", () => {
-        expect(() => parseRenameFlags(["nope"])).toThrow(/expected old=new/);
-        expect(() => parseRenameFlags(["=x"])).toThrow(/expected old=new/);
-        expect(() => parseRenameFlags(["x="])).toThrow(/expected old=new/);
-    });
-});
-describe("readLocalAppManifest", () => {
-    it("reads app_id + knowledge from a pulled app project", () => {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-app-test-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
-                name: "crm",
-                lotics: { app_id: "app_x", knowledge: [{ alias: "sop", doc_id: "kdc_1" }] },
-            }));
-            expect(readLocalAppManifest(dir)).toEqual({
-                app_id: "app_x",
-                knowledge: [{ alias: "sop", doc_id: "kdc_1" }],
-            });
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("returns null when the dir has no package.json", () => {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-empty-"));
-        try {
-            expect(readLocalAppManifest(dir)).toBeNull();
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});
-describe("parseResolveFlags", () => {
-    it("maps 'recreate' and ids to their resolution shapes", () => {
-        expect(parseResolveFlags(["fields.deal.stage=recreate", "templates.quote=dtl_abc"])).toEqual({
-            "fields.deal.stage": "recreate",
-            "templates.quote": { bind_to: "dtl_abc" },
-        });
-    });
-    it("maps modified-core consents 'revert' and 'keep' as literals", () => {
-        expect(parseResolveFlags(["queries.tasks=revert", "workflows.notify=keep"])).toEqual({
-            "queries.tasks": "revert",
-            "workflows.notify": "keep",
-        });
-    });
-    it("rejects entries without a key=value shape", () => {
-        expect(() => parseResolveFlags(["fields.deal.stage"])).toThrow(/Invalid --resolve/);
-        expect(() => parseResolveFlags(["=recreate"])).toThrow(/Invalid --resolve/);
-        expect(() => parseResolveFlags(["fields.deal.stage="])).toThrow(/Invalid --resolve/);
-    });
-});
-describe("parseResolveFlags — the one namespaced grammar", () => {
-    it("passes knowledge verbs through under knowledge.<alias> keys", () => {
-        expect(parseResolveFlags([
-            "knowledge.pricing=apply",
-            "knowledge.faq=keep",
-            "knowledge.old=archive",
-            "knowledge.gone=recreate",
-            "knowledge.legacy=unbind",
-        ])).toEqual({
-            "knowledge.pricing": "apply",
-            "knowledge.faq": "keep",
-            "knowledge.old": "archive",
-            "knowledge.gone": "recreate",
-            "knowledge.legacy": "unbind",
-        });
-    });
-    it("passes template consents through under template.<alias> keys", () => {
-        expect(parseResolveFlags(["template.quote=revert", "template.invoice=keep"])).toEqual({
-            "template.quote": "revert",
-            "template.invoice": "keep",
-        });
-    });
-    it("maps a non-verb value to a bind_to id on any key (roles rebind, knowledge adopt)", () => {
-        expect(parseResolveFlags(["roles.approver=grp_new", "knowledge.faq=kdc_existing"])).toEqual({
-            "roles.approver": { bind_to: "grp_new" },
-            "knowledge.faq": { bind_to: "kdc_existing" },
-        });
-    });
-});
-describe("parseBindToFlags", () => {
-    it("maps each alias to its consent doc id", () => {
-        expect(parseBindToFlags(["playbook=kdc_1", "faq=kdc_2"])).toEqual({
-            playbook: "kdc_1",
-            faq: "kdc_2",
-        });
-    });
-    it("rejects entries without an alias=id shape", () => {
-        expect(() => parseBindToFlags(["playbook"])).toThrow(/Invalid --bind-to/);
-        expect(() => parseBindToFlags(["=kdc_1"])).toThrow(/Invalid --bind-to/);
-        expect(() => parseBindToFlags(["playbook="])).toThrow(/Invalid --bind-to/);
-    });
-});
-describe("parseArgs — app publish --rename", () => {
-    it("captures repeated --rename flags with the positional app id", () => {
-        const { command, subcommand, toolArgs, flags } = parseArgs([
-            "app",
-            "publish",
-            "app_x",
-            "--rename",
-            "item=deal",
-            "--rename",
-            "e.f=name",
-        ]);
-        expect(command).toBe("app");
-        expect(subcommand).toBe("publish");
-        expect(toolArgs).toBe("app_x");
-        expect(flags.rename).toEqual(["item=deal", "e.f=name"]);
-    });
-    it("throws when --rename has no value", () => {
-        expect(() => parseArgs(["app", "publish", "--rename"])).toThrow(/--rename requires a value/);
-        expect(() => parseArgs(["app", "publish", "--rename", "--yes"])).toThrow(/--rename requires a value/);
-    });
-});
-describe("parseArgs — package list-content", () => {
-    it("parses the list-content subcommand with no positional", () => {
-        const { command, subcommand, toolArgs } = parseArgs(["package", "list-content"]);
-        expect(command).toBe("package");
-        expect(subcommand).toBe("list-content");
-        expect(toolArgs).toBeUndefined();
-    });
-    it("captures --workspace for a scoped list-content", () => {
-        const { subcommand, flags } = parseArgs([
-            "package",
-            "list-content",
-            "--workspace",
-            "wsp_dev",
-        ]);
-        expect(subcommand).toBe("list-content");
-        expect(flags.workspace).toBe("wsp_dev");
-    });
-});
-describe("appRelease — knowledge declaration forwarding", () => {
-    const previewResult = {
-        package_id: "apg_1",
-        version: 2,
-        added_aliases: [],
-        changed_artifacts: [],
-        knowledge: { added: ["guide"], removed: [], changed: [] },
-        findings: [],
-    };
-    /** A mock client capturing the knowledge forwarded to preview + release. */
-    function mockClient() {
-        const preview = [];
-        const release = [];
-        const client = {
-            previewPackageRelease: async (app_id, opts = {}) => {
-                preview.push({ app_id, opts });
-                return previewResult;
-            },
-            releasePackage: async (app_id, body) => {
-                release.push({ app_id, body });
-                return { ...previewResult, findings: undefined };
-            },
-        };
-        return { client, preview, release };
-    }
-    function withManifestDir(lotics, fn) {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-rel-"));
-        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "app", lotics }));
-        return fn(dir).finally(() => fs.rmSync(dir, { recursive: true, force: true }));
-    }
-    it("forwards the manifest's knowledge declaration from the app's own project", async () => {
-        vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const { client, preview, release } = mockClient();
-        await withManifestDir({ app_id: "app_x", knowledge: [{ alias: "guide", doc_id: "kdc_1" }] }, async (dir) => {
-            await appRelease(client, { app_id: ".", changelog: "ship", yes: true, projectDir: dir });
-        });
-        expect(preview[0]).toEqual({ app_id: "app_x", opts: { knowledge: [{ alias: "guide", doc_id: "kdc_1" }] } });
-        expect(release[0].body).toEqual({ changelog: "ship", knowledge: [{ alias: "guide", doc_id: "kdc_1" }] });
-        vi.restoreAllMocks();
-    });
-    it("omits knowledge (reconstruct from the pin) when the manifest declares none", async () => {
-        vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const { client, preview, release } = mockClient();
-        await withManifestDir({ app_id: "app_x" }, async (dir) => {
-            await appRelease(client, { app_id: ".", changelog: "ship", yes: true, projectDir: dir });
-        });
-        expect(preview[0].opts).toEqual({ knowledge: undefined });
-        expect(release[0].body).toEqual({ changelog: "ship", knowledge: undefined });
-        vi.restoreAllMocks();
-    });
-    it("omits knowledge for a bare app id whose manifest is a DIFFERENT app", async () => {
-        vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const { client, preview } = mockClient();
-        await withManifestDir({ app_id: "app_other", knowledge: [{ alias: "guide", doc_id: "kdc_1" }] }, async (dir) => {
-            await appRelease(client, { app_id: "app_x", changelog: "ship", yes: true, projectDir: dir });
-        });
-        expect(preview[0]).toEqual({ app_id: "app_x", opts: { knowledge: undefined } });
-        vi.restoreAllMocks();
-    });
-});
-describe("packageUpgradeByPackageId — kind-branched by the package read", () => {
-    /**
-     * A mock client recording which upgrade path a `lotics upgrade <apg_>` takes.
-     * `kind` drives the branch: a content package resolves THIS workspace's content
-     * installation from the package id (the `pci_` never surfaces) and runs the
-     * content upgrade; an app package fleet-upgrades the org.
-     */
-    function mockClient(opts) {
-        const calls = { previewContent: [], fleet: [], listedWorkspaces: [] };
-        const client = {
-            getPackage: async (package_id) => ({
-                id: package_id,
-                name: "Ops corpus",
-                kind: opts.kind,
-                latest_version: 3,
-                is_official: false,
-                retired_at: null,
-            }),
-            getWorkspaceId: () => "wsp_1",
-            listContentInstallations: async (workspace_id) => {
-                calls.listedWorkspaces.push(workspace_id);
-                return (opts.installations ?? []).map((i) => ({
-                    ...i,
-                    workspace_id,
-                    package_version: 2,
-                    app_id: null,
-                    binding: { knowledge: {}, templates: {} },
-                    installed_by: null,
-                    created_at: "",
-                    updated_at: "",
-                    package_registry: null,
-                }));
-            },
-            previewContentInstallationUpgrade: async (installation_id) => {
-                calls.previewContent.push(installation_id);
-                return { from_version: 2, to_version: 2, entries: [], templates: [] };
-            },
-            fleetUpgradePackage: async (package_id) => {
-                calls.fleet.push(package_id);
-                return { package_id, target_version: 3, installations: [] };
-            },
-        };
-        return { client, calls };
-    }
-    const args = { version: undefined, resolve: [], bindTo: [], applyAll: false };
-    it("routes a CONTENT package to this workspace's content installation (resolved from the package id)", async () => {
-        vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const { client, calls } = mockClient({
-            kind: "content",
-            installations: [{ id: "pci_1", package_id: "apg_content" }],
-        });
-        await packageUpgradeByPackageId(client, { package_id: "apg_content", ...args });
-        expect(calls.listedWorkspaces).toEqual(["wsp_1"]);
-        expect(calls.previewContent).toEqual(["pci_1"]); // resolved apg_ → pci_ client-side
-        expect(calls.fleet).toEqual([]); // never a fleet run for content
-        vi.restoreAllMocks();
-    });
-    it("routes an APP package to the org fleet upgrade", async () => {
-        vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const { client, calls } = mockClient({ kind: "app" });
-        await packageUpgradeByPackageId(client, { package_id: "apg_app", ...args });
-        expect(calls.fleet).toEqual(["apg_app"]);
-        expect(calls.previewContent).toEqual([]);
-        expect(calls.listedWorkspaces).toEqual([]); // no content resolution for an app package
-        vi.restoreAllMocks();
-    });
-    it("errors clearly when a content package is not installed in this workspace", async () => {
-        vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const { client } = mockClient({ kind: "content", installations: [] });
-        await expect(packageUpgradeByPackageId(client, { package_id: "apg_content", ...args })).rejects.toThrow(/not installed in this workspace[\s\S]*lotics install apg_content/);
-        vi.restoreAllMocks();
-    });
-});
-describe("formatExtractReport", () => {
-    it("groups findings errors → warnings → info and formats each line", () => {
-        const { lines, hasError } = formatExtractReport([
-            { severity: "info", area: "queries.items", message: "inverted cleanly" },
-            { severity: "error", area: "fields.deal.stage", message: "button field is not portable" },
-            { severity: "warning", area: "workflows.notify", message: "legacy key retained" },
-            { severity: "error", area: "queries.deals", message: "round-trip mismatch" },
-        ]);
-        expect(lines).toEqual([
-            "  [error] fields.deal.stage: button field is not portable",
-            "  [error] queries.deals: round-trip mismatch",
-            "  [warning] workflows.notify: legacy key retained",
-            "  [info] queries.items: inverted cleanly",
-        ]);
-        expect(hasError).toBe(true);
-    });
-    it("reports no error when only warnings/info are present", () => {
-        const { lines, hasError } = formatExtractReport([
-            { severity: "warning", area: "a", message: "w" },
-            { severity: "info", area: "b", message: "i" },
-        ]);
-        expect(lines).toEqual(["  [warning] a: w", "  [info] b: i"]);
-        expect(hasError).toBe(false);
-    });
-    it("handles an empty report", () => {
-        expect(formatExtractReport([])).toEqual({ lines: [], hasError: false });
-    });
-});