@lotics/cli 0.76.0 → 0.83.0

package/dist/package_commands.test.js

@@ -2,139 +2,44 @@ import { describe, it, expect } from "vitest";
 import fs from "node:fs";
 import path from "node:path";
 import { tmpdir } from "node:os";
-import { parseAppPackageContract, validateAppPackageContract, } from "@lotics/shared/schemas/app_packages";
-import { starterContract, readPackageProject, writePackageManifest, sanitizePackageJsonForSource, stagePackageSource, parseResolveFlags, assertDevWorkspace, draftPackageProjectFromApp, parseAdoptBindingFile, formatExtractReport, } from "./package_commands.js";
-describe("starterContract", () => {
-    it("scaffolds a structurally + referentially valid contract", () => {
-        const raw = starterContract("Acme CRM");
-        // Structurally valid against the canonical contract schema.
-        const contract = parseAppPackageContract(raw);
-        // Cross-references (query from_entity, etc.) resolve — zero violations, so the
-        // scaffold publishes without the server's contract validator rejecting it.
-        expect(validateAppPackageContract(contract)).toEqual([]);
+import { parseResolveFlags, parseBindToFlags, parseRenameFlags, readLocalAppManifest, formatExtractReport, } 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("uses the package name as the entity label", () => {
-        const contract = parseAppPackageContract(starterContract("Widgets"));
-        expect(contract.entities[0].label).toBe("Widgets");
-        expect(contract.config[0].default).toBe("Widgets");
+    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("package manifest round-trip", () => {
-    function makeProject() {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-pkg-test-"));
-        fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
-            name: "acme-crm",
-            version: "0.0.1",
-            lotics: {
-                package: { id: null, name: "Acme CRM", description: null, version: null, dev: {} },
-            },
-        }, null, 2) + "\n");
-        return dir;
-    }
-    it("reads the package manifest off package.json#lotics.package", () => {
-        const dir = makeProject();
+describe("readLocalAppManifest", () => {
+    it("reads app_id + knowledge from a pulled app project", () => {
+        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-app-test-"));
         try {
-            const { manifest } = readPackageProject(dir);
-            expect(manifest).toEqual({
-                id: null,
-                name: "Acme CRM",
-                description: null,
-                version: null,
-                dev: {},
+            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("persists publish + dev-installation pins and reads them back", () => {
-        const dir = makeProject();
-        try {
-            const project = readPackageProject(dir);
-            project.manifest.id = "apg_test";
-            project.manifest.version = 3;
-            project.manifest.dev["wsp_dev"] = { app_id: "app_dev", version: 3 };
-            writePackageManifest(dir, project);
-            const reread = readPackageProject(dir);
-            expect(reread.manifest.id).toBe("apg_test");
-            expect(reread.manifest.version).toBe(3);
-            expect(reread.manifest.dev).toEqual({ wsp_dev: { app_id: "app_dev", version: 3 } });
-            // Non-lotics package.json fields survive the manifest write.
-            expect(reread.pkgJson.name).toBe("acme-crm");
-            expect(reread.pkgJson.version).toBe("0.0.1");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-    it("writes the manifest atomically, leaving no temp file behind", () => {
-        const dir = makeProject();
-        try {
-            const project = readPackageProject(dir);
-            project.manifest.id = "apg_atomic";
-            writePackageManifest(dir, project);
-            // The atomic write renames a temp file into place; nothing stray remains.
-            const leftovers = fs.readdirSync(dir).filter((f) => f.startsWith("package.json."));
-            expect(leftovers).toEqual([]);
-            expect(readPackageProject(dir).manifest.id).toBe("apg_atomic");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
-    });
-});
-describe("sanitizePackageJsonForSource", () => {
-    it("strips the author-local lotics.package.dev map", () => {
-        const sanitized = sanitizePackageJsonForSource({
-            name: "acme-crm",
-            version: "0.0.1",
-            lotics: {
-                package: {
-                    id: "apg_x",
-                    name: "Acme CRM",
-                    description: "d",
-                    version: 4,
-                    dev: { wsp_dev: { app_id: "app_dev", version: 4 } },
-                },
-            },
-        });
-        const lotics = sanitized.lotics;
-        // The private dev bookkeeping is gone…
-        expect("dev" in lotics.package).toBe(false);
-        // …while the package identity + other fields survive untouched.
-        expect(lotics.package).toEqual({
-            id: "apg_x",
-            name: "Acme CRM",
-            description: "d",
-            version: 4,
-        });
-        expect(sanitized.name).toBe("acme-crm");
-        expect(sanitized.version).toBe("0.0.1");
-    });
-    it("does not mutate the input package.json", () => {
-        const input = {
-            name: "acme-crm",
-            lotics: { package: { id: "apg_x", name: "Acme CRM", dev: { wsp_dev: { app_id: "a", version: 1 } } } },
-        };
-        sanitizePackageJsonForSource(input);
-        expect(input.lotics.package.dev).toEqual({ wsp_dev: { app_id: "a", version: 1 } });
-    });
-});
-describe("assertDevWorkspace", () => {
-    it("passes a dev workspace", () => {
-        expect(() => assertDevWorkspace({ id: "wsp_d", name: "Dev", is_dev: true })).not.toThrow();
-    });
-    it("fails loud on a non-dev workspace", () => {
-        expect(() => assertDevWorkspace({ id: "wsp_p", name: "Prod", is_dev: false })).toThrow(/not a dev workspace/);
-    });
-    it("fails closed when is_dev is absent (server doesn't serialize it)", () => {
-        expect(() => assertDevWorkspace({ id: "wsp_u", name: "Unknown" })).toThrow(/not a dev workspace/);
-    });
-    it("rejects a directory that is not a package project", () => {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-pkg-test-"));
+    it("returns null when the dir has no package.json", () => {
+        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-empty-"));
         try {
-            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({ name: "plain-app" }));
-            expect(() => readPackageProject(dir)).toThrow(/not a package project/);
+            expect(readLocalAppManifest(dir)).toBeNull();
         }
         finally {
             fs.rmSync(dir, { recursive: true, force: true });
@@ -160,81 +65,85 @@ describe("parseResolveFlags", () => {
         expect(() => parseResolveFlags(["fields.deal.stage="])).toThrow(/Invalid --resolve/);
     });
 });
-describe("draftPackageProjectFromApp", () => {
-    it("strips the app manifest and grafts an unpublished package manifest", () => {
-        const project = draftPackageProjectFromApp({
-            name: "acme-crm",
-            version: "0.0.1",
-            dependencies: { "@lotics/app-sdk": "^1.0.0" },
-            lotics: {
-                app_id: "app_x",
-                workspace_id: "wsp_y",
-                current_version_id: "apv_z",
-                workflows: { notify: { workflow_id: "wfl_1" } },
-            },
-        }, { name: "Acme CRM", description: null });
-        // The app manifest (app_id/workspace_id/workflows) is gone entirely…
-        expect("lotics" in project.pkgJson).toBe(false);
-        // …the package manifest is fresh + unpublished…
-        expect(project.manifest).toEqual({
-            id: null,
-            name: "Acme CRM",
-            description: null,
-            version: null,
-            dev: {},
+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",
         });
-        // …and non-lotics fields survive verbatim.
-        expect(project.pkgJson.name).toBe("acme-crm");
-        expect(project.pkgJson.version).toBe("0.0.1");
-        expect(project.pkgJson.dependencies).toEqual({ "@lotics/app-sdk": "^1.0.0" });
     });
-    it("round-trips through writePackageManifest to a valid package project on disk", () => {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-pkg-test-"));
-        try {
-            writePackageManifest(dir, draftPackageProjectFromApp({ name: "acme-crm", lotics: { app_id: "app_x", workspace_id: "wsp_y" } }, { name: "Acme CRM", description: "A CRM" }));
-            // readPackageProject only accepts a real package project (lotics.package).
-            const { manifest, pkgJson } = readPackageProject(dir);
-            expect(manifest).toEqual({
-                id: null,
-                name: "Acme CRM",
-                description: "A CRM",
-                version: null,
-                dev: {},
-            });
-            // The old app manifest keys never made it to disk.
-            const lotics = pkgJson.lotics;
-            expect("app_id" in lotics).toBe(false);
-            expect("workspace_id" in lotics).toBe(false);
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-        }
+    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("does not mutate the input package.json", () => {
-        const input = { name: "acme-crm", lotics: { app_id: "app_x", workspace_id: "wsp_y" } };
-        draftPackageProjectFromApp(input, { name: "Acme CRM", description: null });
-        expect(input.lotics).toEqual({ app_id: "app_x", workspace_id: "wsp_y" });
+    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("parseAdoptBindingFile", () => {
-    const validPin = {
-        app_id: "app_x",
-        workspace_id: "wsp_y",
-        binding: { entities: { item: "tbl_1" }, fields: {}, options: {}, templates: {}, roles: {}, workflows: {} },
-    };
-    it("accepts a pin whose app_id matches the app being adopted", () => {
-        const pin = parseAdoptBindingFile(validPin, "app_x");
-        expect(pin.app_id).toBe("app_x");
-        expect(pin.workspace_id).toBe("wsp_y");
-        expect(pin.binding.entities).toEqual({ item: "tbl_1" });
+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("REFUSES a pin recorded for a different app", () => {
-        expect(() => parseAdoptBindingFile(validPin, "app_OTHER")).toThrow(/records app app_x, but you are adopting app_OTHER/);
+    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("rejects a malformed pin", () => {
-        expect(() => parseAdoptBindingFile({ app_id: "app_x" }, "app_x")).toThrow(/Malformed/);
-        expect(() => parseAdoptBindingFile(null, "app_x")).toThrow(/Malformed/);
-        expect(() => parseAdoptBindingFile({ app_id: "app_x", workspace_id: "wsp_y" }, "app_x")).toThrow(/Malformed/);
+    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("formatExtractReport", () => {
@@ -265,39 +174,3 @@ describe("formatExtractReport", () => {
         expect(formatExtractReport([])).toEqual({ lines: [], hasError: false });
     });
 });
-describe("stagePackageSource", () => {
-    it("keeps nested dist-named dirs, drops top-level excludes, sanitizes package.json", () => {
-        const dir = fs.mkdtempSync(path.join(tmpdir(), "lotics-stage-test-"));
-        const stage = fs.mkdtempSync(path.join(tmpdir(), "lotics-stage-out-"));
-        try {
-            fs.writeFileSync(path.join(dir, "package.json"), JSON.stringify({
-                name: "pkg",
-                lotics: { package: { id: "apg_x", name: "pkg", version: 3, dev: { wsp_a: "app_1" } } },
-            }));
-            fs.mkdirSync(path.join(dir, "src"));
-            fs.writeFileSync(path.join(dir, "src", "main.tsx"), "export {}");
-            // A nested dir NAMED dist must ship — only the top-level dist is a build output.
-            fs.mkdirSync(path.join(dir, "templates", "dist"), { recursive: true });
-            fs.writeFileSync(path.join(dir, "templates", "dist", "quote.xlsx"), "bytes");
-            fs.mkdirSync(path.join(dir, "dist"));
-            fs.writeFileSync(path.join(dir, "dist", "index.js"), "built");
-            fs.mkdirSync(path.join(dir, "node_modules", "x"), { recursive: true });
-            fs.writeFileSync(path.join(dir, "node_modules", "x", "i.js"), "dep");
-            fs.writeFileSync(path.join(dir, "tsconfig.tsbuildinfo"), "{}");
-            stagePackageSource(dir, stage);
-            expect(fs.existsSync(path.join(stage, "src", "main.tsx"))).toBe(true);
-            expect(fs.existsSync(path.join(stage, "templates", "dist", "quote.xlsx"))).toBe(true);
-            expect(fs.existsSync(path.join(stage, "dist"))).toBe(false);
-            expect(fs.existsSync(path.join(stage, "node_modules"))).toBe(false);
-            expect(fs.existsSync(path.join(stage, "tsconfig.tsbuildinfo"))).toBe(false);
-            // The staged package.json is the sanitized one — dev pins stripped.
-            const staged = JSON.parse(fs.readFileSync(path.join(stage, "package.json"), "utf-8"));
-            expect(staged.lotics.package.dev).toBeUndefined();
-            expect(staged.lotics.package.id).toBe("apg_x");
-        }
-        finally {
-            fs.rmSync(dir, { recursive: true, force: true });
-            fs.rmSync(stage, { recursive: true, force: true });
-        }
-    });
-});