@multiplatform.one/cli 7.90.3 → 7.90.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,207 @@
1
+ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
2
+ import { tmpdir } from "node:os";
3
+ import { dirname, join } from "node:path";
4
+ import { waitForMariaDB, waitServices } from "@multiplatform.one/utils/dev";
5
+ import nanoSpawn from "nano-spawn";
6
+ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
7
+ import {
8
+ availableServices,
9
+ parseTestTiers,
10
+ runBuild,
11
+ runFrappeBench,
12
+ runIntegrationTests,
13
+ runTurboLint,
14
+ runUnitTests,
15
+ waitFunctions,
16
+ } from "./verbs";
17
+
18
+ type Spawn = typeof nanoSpawn;
19
+
20
+ type Call = { file: string; args: string[]; cwd?: string };
21
+
22
+ // Records every spawn and stands a real `sh -c` in for it, so a failure is
23
+ // nano-spawn's own error. `fail` picks the calls that exit 1.
24
+ function recorder(fail: (call: Call) => boolean = () => false) {
25
+ const calls: Call[] = [];
26
+ const spawn = ((file: string, args: readonly string[] = [], options: { cwd?: string } = {}) => {
27
+ const call = { file, args: [...args], cwd: options.cwd };
28
+ calls.push(call);
29
+ return nanoSpawn("sh", ["-c", fail(call) ? "exit 1" : "true"]);
30
+ }) as Spawn;
31
+ return { calls, spawn };
32
+ }
33
+
34
+ function write(root: string, file: string, body: string) {
35
+ mkdirSync(dirname(join(root, file)), { recursive: true });
36
+ writeFileSync(join(root, file), body);
37
+ }
38
+
39
+ function plantBench(root: string, { bootstrapped }: { bootstrapped: boolean }) {
40
+ write(root, "apps/frappe/package.json", JSON.stringify({ name: "@service/frappe" }));
41
+ write(root, "apps/frappe/frappe.yaml", "apps:\n - ./apps/core\n - ./apps/live\n");
42
+ write(root, "apps/frappe/apps/core/pyproject.toml", "[tool.pytest.ini_options]\n");
43
+ write(root, "apps/frappe/apps/live/pyproject.toml", "[tool.pytest.ini_options]\n");
44
+ if (bootstrapped) mkdirSync(join(root, "apps/frappe/sites"), { recursive: true });
45
+ }
46
+
47
+ const isTurboTest = (call: Call) =>
48
+ call.file === "pnpm" && call.args.slice(0, 3).join(" ") === "turbo run test";
49
+
50
+ const benchCalls = (calls: Call[]) => calls.filter((call) => call.file === "bench");
51
+
52
+ describe("mpo test tiers (FZ-10496)", () => {
53
+ let root: string;
54
+
55
+ beforeEach(() => {
56
+ root = mkdtempSync(join(tmpdir(), "mpo-verbs-spec-"));
57
+ write(root, "apps/one/package.json", JSON.stringify({ name: "@platform/one" }));
58
+ });
59
+
60
+ afterEach(() => {
61
+ rmSync(root, { recursive: true, force: true });
62
+ vi.restoreAllMocks();
63
+ });
64
+
65
+ it("runs the unit tier when no tier is named", () => {
66
+ expect(parseTestTiers([])).toEqual(["unit"]);
67
+ expect(parseTestTiers(["unit,integration"])).toEqual(["unit", "integration"]);
68
+ expect(parseTestTiers(["e2e"])).toEqual(["e2e"]);
69
+ });
70
+
71
+ it("refuses a tier it does not have instead of running nothing", () => {
72
+ expect(() => parseTestTiers(["storybook"])).toThrow(
73
+ "unknown test tier storybook (unit, integration, e2e, visual)",
74
+ );
75
+ });
76
+
77
+ it("unit runs turbo test, then the bench's non-integration tests", async () => {
78
+ plantBench(root, { bootstrapped: true });
79
+ const { calls, spawn } = recorder();
80
+ await runUnitTests(root, spawn);
81
+ expect(calls[0]).toMatchObject({ file: "pnpm", args: ["turbo", "run", "test"], cwd: root });
82
+ expect(benchCalls(calls).map((call) => call.args)).toEqual([
83
+ ["run-tests", "--app", "core", "--", "-m", "not integration"],
84
+ ["run-tests", "--app", "live", "--", "-m", "not integration"],
85
+ ]);
86
+ expect(benchCalls(calls)[0].cwd).toBe(join(root, "apps/frappe"));
87
+ });
88
+
89
+ it("integration never runs the turbo test task unit already ran", async () => {
90
+ plantBench(root, { bootstrapped: true });
91
+ const { calls, spawn } = recorder();
92
+ await runIntegrationTests(root, spawn);
93
+ expect(calls.filter(isTurboTest)).toEqual([]);
94
+ expect(calls.map((call) => [call.file, ...call.args])).toEqual([
95
+ ["bench", "run-tests", "--app", "core", "--", "-m", "integration"],
96
+ ["bench", "run-tests", "--app", "live", "--", "-m", "integration"],
97
+ ]);
98
+ });
99
+
100
+ it("a bootstrapped bench that fails fails integration, after every app ran", async () => {
101
+ plantBench(root, { bootstrapped: true });
102
+ vi.spyOn(console, "error").mockImplementation(() => {});
103
+ const { calls, spawn } = recorder((call) => call.args.includes("core"));
104
+ await expect(runIntegrationTests(root, spawn)).rejects.toThrow(
105
+ 'bench tests -m "integration" failed: core',
106
+ );
107
+ expect(benchCalls(calls)).toHaveLength(2);
108
+ });
109
+
110
+ it("a bootstrapped bench that fails fails unit too", async () => {
111
+ plantBench(root, { bootstrapped: true });
112
+ vi.spyOn(console, "error").mockImplementation(() => {});
113
+ const { spawn } = recorder((call) => call.file === "bench");
114
+ await expect(runUnitTests(root, spawn)).rejects.toThrow(
115
+ 'bench tests -m "not integration" failed: core, live',
116
+ );
117
+ });
118
+
119
+ it("a bench that is not bootstrapped is skipped with a note, not run", async () => {
120
+ plantBench(root, { bootstrapped: false });
121
+ const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
122
+ const { calls, spawn } = recorder();
123
+ await runIntegrationTests(root, spawn);
124
+ expect(calls).toEqual([]);
125
+ expect(warn).toHaveBeenCalledWith(
126
+ 'no frappe bench (apps/frappe/sites): skipped bench tests -m "integration"',
127
+ );
128
+ });
129
+ });
130
+
131
+ describe("mpo build (FZ-10496)", () => {
132
+ let root: string;
133
+
134
+ beforeEach(() => {
135
+ root = mkdtempSync(join(tmpdir(), "mpo-verbs-spec-"));
136
+ const build = { scripts: { build: "true" } };
137
+ write(root, "apps/one/package.json", JSON.stringify(build));
138
+ write(root, "apps/solana/package.json", JSON.stringify(build));
139
+ write(root, "apps/sui/package.json", JSON.stringify(build));
140
+ });
141
+
142
+ afterEach(() => {
143
+ rmSync(root, { recursive: true, force: true });
144
+ });
145
+
146
+ it("has no api service", () => {
147
+ expect(availableServices).not.toContain("api");
148
+ });
149
+
150
+ it("builds each chain service once", async () => {
151
+ const { calls, spawn } = recorder();
152
+ await runBuild([], root, spawn);
153
+ const filters = calls.map((call) => call.args.at(-1));
154
+ expect(filters.filter((f) => f === "--filter=./apps/solana")).toHaveLength(1);
155
+ expect(filters.filter((f) => f === "--filter=./apps/sui")).toHaveLength(1);
156
+ expect(filters.filter((f) => f === "--filter=./apps/one")).toHaveLength(1);
157
+ });
158
+
159
+ it("builds a named service once", async () => {
160
+ const { calls, spawn } = recorder();
161
+ await runBuild(["solana"], root, spawn);
162
+ expect(calls.map((call) => [call.file, ...call.args])).toEqual([
163
+ ["pnpm", "turbo", "run", "build", "--filter=./apps/solana"],
164
+ ]);
165
+ });
166
+ });
167
+
168
+ describe("mpo lint (FZ-10496)", () => {
169
+ it("runs the root lint task and no typecheck", async () => {
170
+ const { calls, spawn } = recorder();
171
+ expect(await runTurboLint("/project", spawn)).toBe(false);
172
+ expect(calls).toEqual([
173
+ { file: "turbo", args: ["run", "lint", "--filter=//"], cwd: "/project" },
174
+ ]);
175
+ });
176
+
177
+ it("reports a failed lint", async () => {
178
+ const { spawn } = recorder(() => true);
179
+ expect(await runTurboLint("/project", spawn)).toBe(true);
180
+ });
181
+ });
182
+
183
+ describe("mpo frappe bench (FZ-10496)", () => {
184
+ it("passes the arguments after -- to bench as given", async () => {
185
+ const { calls, spawn } = recorder();
186
+ await runFrappeBench(
187
+ ["--site", "my site", "migrate"],
188
+ "/cli/scripts/frappe.sh",
189
+ "/project",
190
+ spawn,
191
+ );
192
+ expect(calls).toEqual([
193
+ {
194
+ file: "sh",
195
+ args: ["/cli/scripts/frappe.sh", "bench", "--site", "my site", "migrate"],
196
+ cwd: "/project",
197
+ },
198
+ ]);
199
+ });
200
+ });
201
+
202
+ describe("mpo wait (FZ-10496)", () => {
203
+ it("has a probe for every service its help lists", () => {
204
+ expect(Object.keys(waitFunctions).sort()).toEqual([...waitServices].sort());
205
+ expect(waitFunctions.mariadb).toBe(waitForMariaDB);
206
+ });
207
+ });
@@ -0,0 +1,262 @@
1
+ import fsSync from "node:fs";
2
+ import fs from "node:fs/promises";
3
+ import path from "node:path";
4
+ import {
5
+ type WaitService,
6
+ waitForFrappe,
7
+ waitForKeycloak,
8
+ waitForMariaDB,
9
+ waitForPostgres,
10
+ } from "@multiplatform.one/utils/dev";
11
+ import nanoSpawn from "nano-spawn";
12
+ import YAML from "yaml";
13
+ import { discoverE2EApp } from "./e2e";
14
+
15
+ type Spawn = typeof nanoSpawn;
16
+
17
+ export const availableServices = ["frappe", "solana", "ethereum", "sui"];
18
+
19
+ /** Map a service name to its relative directory from the project root. */
20
+ function serviceDir(name: string): string {
21
+ return `apps/${name}`;
22
+ }
23
+
24
+ /** Apps that exist under apps/ and have package.json (discovered from filesystem). */
25
+ async function getPresentApps(root: string): Promise<string[]> {
26
+ const appsDir = path.join(root, "apps");
27
+ try {
28
+ const entries = await fs.readdir(appsDir, { withFileTypes: true });
29
+ const names: string[] = [];
30
+ for (const e of entries) {
31
+ if (!e.isDirectory()) continue;
32
+ const pkgPath = path.join(appsDir, e.name, "package.json");
33
+ try {
34
+ await fs.access(pkgPath);
35
+ names.push(e.name);
36
+ } catch {
37
+ // no package.json
38
+ }
39
+ }
40
+ return names;
41
+ } catch {
42
+ return [];
43
+ }
44
+ }
45
+
46
+ /** Root-level services that exist and have package.json (discovered from filesystem). */
47
+ async function getPresentServices(root: string): Promise<string[]> {
48
+ const names: string[] = [];
49
+ for (const name of availableServices) {
50
+ const dir = path.join(root, serviceDir(name));
51
+ const pkgPath = path.join(dir, "package.json");
52
+ try {
53
+ const stat = await fs.stat(dir);
54
+ if (!stat.isDirectory()) continue;
55
+ await fs.access(pkgPath);
56
+ names.push(name);
57
+ } catch {
58
+ // dir or package.json missing
59
+ }
60
+ }
61
+ return names;
62
+ }
63
+
64
+ /** Turbo --filter args to exclude root-level workspaces that are not present (so turbo only runs where they exist).
65
+ * Only generates exclude filters for directories that exist on disk (turbo errors on non-existent filter paths). */
66
+ async function getTurboExcludeFiltersForMissing(root: string): Promise<string[]> {
67
+ const present = await getPresentServices(root);
68
+ const filters: string[] = [];
69
+ for (const s of availableServices) {
70
+ if (present.includes(s)) continue;
71
+ const dir = serviceDir(s);
72
+ try {
73
+ const stat = await fs.stat(path.join(root, dir));
74
+ if (stat.isDirectory()) filters.push(`!./${dir}`);
75
+ } catch {
76
+ // directory doesn't exist; turbo won't find it, no filter needed
77
+ }
78
+ }
79
+ return filters;
80
+ }
81
+
82
+ /** Discover frappe apps from frappe.yaml that have local source paths.
83
+ * Supports both string entries (`- ./apps/core`) and object entries (`- name: core\n source: ./apps/core`). */
84
+ async function getFrappeApps(root: string): Promise<{ name: string; absolutePath: string }[]> {
85
+ const frappeDir = path.join(root, "apps", "frappe");
86
+ const frappeYamlPath = path.join(frappeDir, "frappe.yaml");
87
+ if (!fsSync.existsSync(frappeYamlPath)) return [];
88
+ const raw = await fs.readFile(frappeYamlPath, "utf8");
89
+ const config = YAML.parse(raw) as { apps?: (string | { name?: string; source?: string })[] };
90
+ const out: { name: string; absolutePath: string }[] = [];
91
+ for (const app of config?.apps ?? []) {
92
+ let src: string;
93
+ let name: string;
94
+ if (typeof app === "string") {
95
+ src = app;
96
+ name = path.basename(app);
97
+ } else {
98
+ if (!app.source || !app.name) continue;
99
+ src = app.source;
100
+ name = app.name;
101
+ }
102
+ src = src.startsWith("file://") ? src.slice(7) : src;
103
+ if (!src.startsWith("./") && !src.startsWith("../") && !src.startsWith("/")) continue;
104
+ const absPath = path.isAbsolute(src) ? src : path.resolve(frappeDir, src);
105
+ if (!fsSync.existsSync(absPath)) continue;
106
+ out.push({ name, absolutePath: absPath });
107
+ }
108
+ return out;
109
+ }
110
+
111
+ export const testTiers = ["unit", "integration", "e2e", "visual"] as const;
112
+
113
+ export type TestTier = (typeof testTiers)[number];
114
+
115
+ /** The tiers `mpo test` was asked for (comma or space separated); unit when none is named. */
116
+ export function parseTestTiers(args: string[]): TestTier[] {
117
+ const parsed = args.flatMap((arg) => arg.split(",")).filter(Boolean);
118
+ for (const tier of parsed) {
119
+ if (!(testTiers as readonly string[]).includes(tier)) {
120
+ throw new Error(`unknown test tier ${tier} (${testTiers.join(", ")})`);
121
+ }
122
+ }
123
+ return parsed.length ? (parsed as TestTier[]) : ["unit"];
124
+ }
125
+
126
+ /**
127
+ * `bench run-tests` for every frappe app with a pyproject.toml, limited to the
128
+ * pytest marker expression. Skipped when the bench is not bootstrapped
129
+ * (no apps/frappe/sites); once it is, any app whose run fails fails the tier.
130
+ */
131
+ async function runBenchTests(projectRoot: string, marker: string, spawn: Spawn): Promise<void> {
132
+ const benchDir = path.join(projectRoot, "apps", "frappe");
133
+ const apps = (await getFrappeApps(projectRoot)).filter((app) =>
134
+ fsSync.existsSync(path.join(app.absolutePath, "pyproject.toml")),
135
+ );
136
+ if (!apps.length) return;
137
+ if (!fsSync.existsSync(path.join(benchDir, "sites"))) {
138
+ console.warn(`no frappe bench (apps/frappe/sites): skipped bench tests -m "${marker}"`);
139
+ return;
140
+ }
141
+ const failed: string[] = [];
142
+ for (const app of apps) {
143
+ try {
144
+ await spawn("bench", ["run-tests", "--app", app.name, "--", "-m", marker], {
145
+ stdio: "inherit",
146
+ cwd: benchDir,
147
+ });
148
+ } catch (error) {
149
+ console.error((error as Error).message);
150
+ failed.push(app.name);
151
+ }
152
+ }
153
+ if (failed.length) {
154
+ throw new Error(`bench tests -m "${marker}" failed: ${failed.join(", ")}`);
155
+ }
156
+ }
157
+
158
+ /** The unit tier: turbo test minus missing services and the e2e app, then the bench's non-integration tests. */
159
+ export async function runUnitTests(projectRoot: string, spawn: Spawn = nanoSpawn): Promise<void> {
160
+ const excludeFilters = await getTurboExcludeFiltersForMissing(projectRoot);
161
+ const e2eApp = await discoverE2EApp(projectRoot);
162
+ const filters = [
163
+ ...excludeFilters.flatMap((f) => ["--filter", f]),
164
+ ...(e2eApp ? ["--filter", `'!./apps/${e2eApp}'`] : []),
165
+ ];
166
+ await spawn("pnpm", ["turbo", "run", "test", ...filters], {
167
+ stdio: "inherit",
168
+ shell: true,
169
+ cwd: projectRoot,
170
+ });
171
+ await runBenchTests(projectRoot, "not integration", spawn);
172
+ }
173
+
174
+ /** The integration tier: the bench's integration-marked tests only; the JS suite belongs to unit. */
175
+ export async function runIntegrationTests(
176
+ projectRoot: string,
177
+ spawn: Spawn = nanoSpawn,
178
+ ): Promise<void> {
179
+ await runBenchTests(projectRoot, "integration", spawn);
180
+ }
181
+
182
+ /** `mpo build`: the packages, then every present app with a build script, each once. */
183
+ export async function runBuild(
184
+ args: string[],
185
+ projectRoot: string,
186
+ spawn: Spawn = nanoSpawn,
187
+ ): Promise<void> {
188
+ const parsed = args.flatMap((arg) => arg.split(","));
189
+ const packages = parsed.includes("packages");
190
+ const projects = parsed.filter((arg) => arg !== "packages");
191
+ const presentApps = await getPresentApps(projectRoot);
192
+ const presentServices = await getPresentServices(projectRoot);
193
+ if ((!projects.length && !packages) || packages) {
194
+ await spawn(
195
+ "pnpm",
196
+ [
197
+ "turbo",
198
+ "run",
199
+ "build",
200
+ "--filter",
201
+ "'!./apps/*'",
202
+ ...presentServices.flatMap((s) => ["--filter", `'!./${serviceDir(s)}'`]),
203
+ ],
204
+ {
205
+ stdio: "inherit",
206
+ shell: true,
207
+ cwd: projectRoot,
208
+ },
209
+ );
210
+ }
211
+ for (const platform of presentApps) {
212
+ if ((!projects.length && !packages) || projects.includes(platform)) {
213
+ const hasBuild = await fs
214
+ .access(path.join(projectRoot, "apps", platform, "package.json"))
215
+ .then(
216
+ () =>
217
+ JSON.parse(
218
+ fsSync.readFileSync(path.join(projectRoot, "apps", platform, "package.json"), "utf8"),
219
+ ).scripts?.build,
220
+ )
221
+ .catch(() => false);
222
+ if (hasBuild) {
223
+ await spawn("pnpm", ["turbo", "run", "build", `--filter=./apps/${platform}`], {
224
+ stdio: "inherit",
225
+ shell: true,
226
+ cwd: projectRoot,
227
+ });
228
+ }
229
+ }
230
+ }
231
+ }
232
+
233
+ /** `mpo lint`'s turbo half: the root `//#lint` task. Resolves true when it failed. */
234
+ export async function runTurboLint(
235
+ projectRoot: string,
236
+ spawn: Spawn = nanoSpawn,
237
+ ): Promise<boolean> {
238
+ try {
239
+ await spawn("turbo", ["run", "lint", "--filter=//"], { stdio: "inherit", cwd: projectRoot });
240
+ return false;
241
+ } catch {
242
+ return true;
243
+ }
244
+ }
245
+
246
+ /** `mpo frappe bench [args...]`: frappe.sh's bench command with the arguments passed through as given. */
247
+ export async function runFrappeBench(
248
+ args: string[],
249
+ frappeScript: string,
250
+ projectRoot: string,
251
+ spawn: Spawn = nanoSpawn,
252
+ ): Promise<void> {
253
+ await spawn("sh", [frappeScript, "bench", ...args], { stdio: "inherit", cwd: projectRoot });
254
+ }
255
+
256
+ /** The readiness probe behind each `mpo wait` service. */
257
+ export const waitFunctions: Record<WaitService, (interval: number) => Promise<void>> = {
258
+ frappe: waitForFrappe,
259
+ postgres: waitForPostgres,
260
+ mariadb: waitForMariaDB,
261
+ keycloak: waitForKeycloak,
262
+ };
@@ -1 +1 @@
1
- {"version":3,"file":"multiplatformOne.d.ts","sourceRoot":"","sources":["../../src/bin/multiplatformOne.ts"],"names":[],"mappings":"AA8FA,gHAAgH;AAChH,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,kGAAkG;IAClG,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC"}
1
+ {"version":3,"file":"multiplatformOne.d.ts","sourceRoot":"","sources":["../../src/bin/multiplatformOne.ts"],"names":[],"mappings":"AAsCA,gHAAgH;AAChH,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,kGAAkG;IAClG,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC"}
@@ -0,0 +1,22 @@
1
+ import { type WaitService } from "@multiplatform.one/utils/dev";
2
+ import nanoSpawn from "nano-spawn";
3
+ type Spawn = typeof nanoSpawn;
4
+ export declare const availableServices: string[];
5
+ export declare const testTiers: readonly ["unit", "integration", "e2e", "visual"];
6
+ export type TestTier = (typeof testTiers)[number];
7
+ /** The tiers `mpo test` was asked for (comma or space separated); unit when none is named. */
8
+ export declare function parseTestTiers(args: string[]): TestTier[];
9
+ /** The unit tier: turbo test minus missing services and the e2e app, then the bench's non-integration tests. */
10
+ export declare function runUnitTests(projectRoot: string, spawn?: Spawn): Promise<void>;
11
+ /** The integration tier: the bench's integration-marked tests only; the JS suite belongs to unit. */
12
+ export declare function runIntegrationTests(projectRoot: string, spawn?: Spawn): Promise<void>;
13
+ /** `mpo build`: the packages, then every present app with a build script, each once. */
14
+ export declare function runBuild(args: string[], projectRoot: string, spawn?: Spawn): Promise<void>;
15
+ /** `mpo lint`'s turbo half: the root `//#lint` task. Resolves true when it failed. */
16
+ export declare function runTurboLint(projectRoot: string, spawn?: Spawn): Promise<boolean>;
17
+ /** `mpo frappe bench [args...]`: frappe.sh's bench command with the arguments passed through as given. */
18
+ export declare function runFrappeBench(args: string[], frappeScript: string, projectRoot: string, spawn?: Spawn): Promise<void>;
19
+ /** The readiness probe behind each `mpo wait` service. */
20
+ export declare const waitFunctions: Record<WaitService, (interval: number) => Promise<void>>;
21
+ export {};
22
+ //# sourceMappingURL=verbs.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"verbs.d.ts","sourceRoot":"","sources":["../../src/commands/verbs.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,SAAS,MAAM,YAAY,CAAC;AAInC,KAAK,KAAK,GAAG,OAAO,SAAS,CAAC;AAE9B,eAAO,MAAM,iBAAiB,UAA0C,CAAC;AA8FzE,eAAO,MAAM,SAAS,mDAAoD,CAAC;AAE3E,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAElD,8FAA8F;AAC9F,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,CAQzD;AAkCD,gHAAgH;AAChH,wBAAsB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,GAAE,KAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAa/F;AAED,qGAAqG;AACrG,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,KAAiB,GACvB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wFAAwF;AACxF,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,MAAM,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,KAAiB,GACvB,OAAO,CAAC,IAAI,CAAC,CA4Cf;AAED,sFAAsF;AACtF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,KAAiB,GACvB,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,0GAA0G;AAC1G,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EAAE,EACd,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,KAAiB,GACvB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,0DAA0D;AAC1D,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAKlF,CAAC"}
package/lib/types.mjs DELETED
@@ -1 +0,0 @@
1
- export { };
package/src/types.ts DELETED
@@ -1,5 +0,0 @@
1
- /**
2
- * CLI type definitions placeholder.
3
- * Add CLI-specific types here as needed.
4
- */
5
- export {};
package/types/types.d.ts DELETED
@@ -1,6 +0,0 @@
1
- /**
2
- * CLI type definitions placeholder.
3
- * Add CLI-specific types here as needed.
4
- */
5
- export {};
6
- //# sourceMappingURL=types.d.ts.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,CAAC"}