@plico-ai/cli 0.0.0-reserved.0 → 0.1.0

package/dist/commands/runs.js

@@ -0,0 +1,52 @@
+import { access } from "node:fs/promises";
+import { createSqliteEventStore } from "@plico-ai/runtime";
+import { lastPositional, parseArgs, readStringOption } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { formatRunSummaries } from "../format/runs.js";
+import { resolveDatabasePath } from "../paths.js";
+export async function runsCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--json"],
+            values: { "--db": { missing: "Missing database path after --db" } },
+            rejectUnknown: true,
+        });
+        const json = parsed.flags.has("--json");
+        const target = lastPositional(parsed, process.cwd());
+        const dbPath = readStringOption(parsed, "--db");
+        const databasePath = resolveDatabasePath(target, dbPath);
+        try {
+            await access(databasePath);
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+                throw error;
+            }
+            if (dbPath !== undefined)
+                throw new Error(`Missing database: ${databasePath}`);
+            if (parsed.flags.has("--json"))
+                console.log("[]");
+            else
+                console.log("No saved runs found.");
+            return 0;
+        }
+        const eventStore = createSqliteEventStore({ databasePath });
+        const runs = await eventStore.listRuns();
+        if (json) {
+            console.log(JSON.stringify(runs));
+        }
+        else if (runs.length === 0) {
+            console.log("No saved runs found.");
+        }
+        else {
+            for (const line of formatRunSummaries(target, databasePath, runs)) {
+                console.log(line);
+            }
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1 @@
+export declare function serveCommand(args: string[]): Promise<number>;

package/dist/commands/serve.js

@@ -0,0 +1,61 @@
+import { isIPv4 } from "node:net";
+import { loadProjectEnv } from "@plico-ai/runtime";
+import { lastPositional, parseArgs, parsePort, readNumberOption, readStringOption, } from "../args.js";
+import { errorMessage } from "../errors.js";
+import { findStudioPath, normalizeDisplayHost, resolveDatabasePath } from "../paths.js";
+export async function serveCommand(args) {
+    try {
+        const parsed = parseArgs(args, {
+            flags: ["--studio", "--allow-remote", "--allow-script", "--inspect"],
+            values: {
+                "--host": { missing: "Missing host after --host" },
+                "--port": { missing: "Missing port after --port", parse: parsePort },
+                "--db": { missing: "Missing database path after --db" },
+            },
+            rejectUnknown: true,
+        });
+        const target = lastPositional(parsed, process.cwd());
+        loadProjectEnv(target);
+        const host = readStringOption(parsed, "--host");
+        const port = readNumberOption(parsed, "--port");
+        if (host !== undefined && !isLoopbackHost(host) && !parsed.flags.has("--allow-remote")) {
+            throw new Error(`Refusing to listen on ${host}: Plico has no authentication. Pass --allow-remote to expose it.`);
+        }
+        const databasePath = resolveDatabasePath(target, readStringOption(parsed, "--db"));
+        const studioPath = parsed.flags.has("--studio") ? resolveStudioPath() : undefined;
+        const { servePlico } = await import("@plico-ai/server");
+        const server = await servePlico({
+            projectRoot: target,
+            databasePath,
+            ...(host === undefined ? {} : { host }),
+            ...(port === undefined ? {} : { port }),
+            ...(studioPath === undefined ? {} : { studioPath }),
+            ...(parsed.flags.has("--allow-remote") ? { allowRemote: true } : {}),
+            ...(parsed.flags.has("--allow-script") ? { allowScript: true } : {}),
+            ...(parsed.flags.has("--inspect") ? { inspect: true } : {}),
+        });
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            throw new Error("Unable to determine the listening address.");
+        }
+        const resolvedHost = normalizeDisplayHost(host ?? "127.0.0.1");
+        const urlHost = resolvedHost.includes(":") ? `[${resolvedHost}]` : resolvedHost;
+        console.log(`Serving Plico at http://${urlHost}:${address.port}`);
+        console.log(`Database: ${databasePath}`);
+        return 0;
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+}
+function resolveStudioPath() {
+    const studioPath = findStudioPath();
+    if (studioPath === undefined) {
+        throw new Error("Cannot find the Studio assets. From a source checkout, build them with: pnpm --filter @plico-ai/studio build");
+    }
+    return studioPath;
+}
+function isLoopbackHost(host) {
+    return host === "localhost" || host === "::1" || (isIPv4(host) && host.startsWith("127."));
+}

package/dist/commands/usage.d.ts

@@ -0,0 +1 @@
+export declare function usageCommand(stream?: "stdout" | "stderr"): number;

package/dist/commands/usage.js

@@ -0,0 +1,18 @@
+const USAGE_LINES = [
+    "Usage: plico validate [path]",
+    "Usage: plico run [--db <path>] [--json] [--message <text>] [path]",
+    "Usage: plico run --dry [--persist] [--db <path>] [--json] [--script <file>] [--message <text>] [path]",
+    "Usage: plico cancel <runId> [--db <path>] [--json] [path]",
+    "Usage: plico runs [--db <path>] [--json] [path]",
+    "Usage: plico events <runId> [--after <sequence>] [--db <path>] [--json] [path]",
+    "Usage: plico eval [--json] [--allow-empty] [--from-run <run-id> [--name <name>]] [--db <path>] [path]",
+    "Usage: plico readiness [--json] [--db <path>] [path]",
+    "Usage: plico serve [--host <host>] [--port <port>] [--db <path>] [--studio] [--allow-remote] [--allow-script] [--inspect] [path]",
+];
+export function usageCommand(stream = "stdout") {
+    const write = stream === "stdout" ? console.log : console.error;
+    for (const line of USAGE_LINES) {
+        write(line);
+    }
+    return 0;
+}

package/dist/commands/validate.d.ts

@@ -0,0 +1 @@
+export declare function validateCommand(args: string[]): Promise<number>;

package/dist/commands/validate.js

@@ -0,0 +1,38 @@
+import { validateProject } from "@plico-ai/core";
+import { lastPositional, parseArgs } from "../args.js";
+import { errorMessage } from "../errors.js";
+export async function validateCommand(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log("Usage: plico validate [path]");
+        return 0;
+    }
+    let parsed;
+    try {
+        parsed = parseArgs(args, { flags: ["--json"], values: {}, rejectUnknown: true });
+    }
+    catch (error) {
+        console.error(errorMessage(error));
+        return 1;
+    }
+    const json = parsed.flags.has("--json");
+    const target = lastPositional(parsed, process.cwd());
+    const result = await validateProject(target);
+    if (json) {
+        console.log(JSON.stringify(result));
+        return result.ok ? 0 : 1;
+    }
+    if (result.ok) {
+        for (const warning of result.warnings) {
+            console.warn(`${warning.path}: ${warning.message}`);
+        }
+        console.log(`Valid Plico project: ${target}`);
+        return 0;
+    }
+    for (const error of result.errors) {
+        console.error(`${error.path}: ${error.message}`);
+    }
+    for (const warning of result.warnings) {
+        console.warn(`${warning.path}: ${warning.message}`);
+    }
+    return 1;
+}

package/dist/direct-run.d.ts

@@ -0,0 +1,5 @@
+/**
+ * True when this module is the script node was started with. npm and pnpm reach a bin through a
+ * symlink, so compare resolved paths rather than the raw `argv[1]` and module URL.
+ */
+export declare function isDirectRun(moduleUrl: string, entry: string | undefined): boolean;

package/dist/direct-run.js

@@ -0,0 +1,16 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+/**
+ * True when this module is the script node was started with. npm and pnpm reach a bin through a
+ * symlink, so compare resolved paths rather than the raw `argv[1]` and module URL.
+ */
+export function isDirectRun(moduleUrl, entry) {
+    if (!entry)
+        return false;
+    try {
+        return realpathSync.native(entry) === realpathSync.native(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1 @@
+export declare function errorMessage(error: unknown): string;

package/dist/errors.js

@@ -0,0 +1,6 @@
+export function errorMessage(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/format/eval.d.ts

@@ -0,0 +1,2 @@
+import type { EvalSummary } from "@plico-ai/runtime";
+export declare function formatEvalSummary(target: string, summary: EvalSummary): string[];

package/dist/format/eval.js

@@ -0,0 +1,18 @@
+export function formatEvalSummary(target, summary) {
+    const lines = [`Eval results for ${target}`];
+    if (summary.total === 0) {
+        lines.push("No eval cases found.");
+        return lines;
+    }
+    for (const result of summary.results) {
+        const statusSymbol = result.status === "pass" ? "PASS" : "FAIL";
+        lines.push(`  ${statusSymbol} ${result.name} (${result.runId})`);
+        if (result.diagnostics?.length) {
+            for (const diag of result.diagnostics) {
+                lines.push(`       ${diag}`);
+            }
+        }
+    }
+    lines.push(`\n${summary.passed}/${summary.total} passed, ${summary.failed} failed`);
+    return lines;
+}

package/dist/format/events.d.ts

@@ -0,0 +1,2 @@
+import type { PlicoEvent } from "@plico-ai/runtime";
+export declare function formatEvents(runId: string, events: PlicoEvent[]): string[];

package/dist/format/events.js

@@ -0,0 +1,7 @@
+export function formatEvents(runId, events) {
+    const lines = [`Events for ${runId}`];
+    for (const event of events) {
+        lines.push(`${event.sequence} ${event.type} ${JSON.stringify(event.payload)}`);
+    }
+    return lines;
+}

package/dist/format/readiness.d.ts

@@ -0,0 +1,2 @@
+import type { ReadinessReport } from "@plico-ai/runtime";
+export declare function formatReadinessReport(report: ReadinessReport): string[];

package/dist/format/readiness.js

@@ -0,0 +1,18 @@
+export function formatReadinessReport(report) {
+    const lines = [];
+    const subsystems = new Set(report.diagnostics.map((d) => d.subsystem));
+    for (const sub of subsystems) {
+        const items = report.diagnostics.filter((d) => d.subsystem === sub);
+        const hasError = items.some((d) => d.severity === "error");
+        const hasWarning = items.some((d) => d.severity === "warning");
+        const symbol = hasError ? "✗" : hasWarning ? "!" : "✓";
+        lines.push(`${symbol} ${sub}`);
+        for (const item of items) {
+            const prefix = item.severity === "error" ? "  ERROR" : item.severity === "warning" ? "  WARN " : "  OK   ";
+            const pathInfo = item.path ? ` [${item.path}]` : "";
+            lines.push(`${prefix}${pathInfo} ${item.message}`);
+        }
+    }
+    lines.push(`\n${report.summary.ok} ok, ${report.summary.warning} warning(s), ${report.summary.error} error(s)`);
+    return lines;
+}

package/dist/format/run.d.ts

@@ -0,0 +1,2 @@
+import type { RunResult } from "@plico-ai/runtime";
+export declare function formatRunResult(target: string, result: RunResult, dry?: boolean): string[];

package/dist/format/run.js

@@ -0,0 +1,69 @@
+import { readCount, readString } from "./values.js";
+export function formatRunResult(target, result, dry = true) {
+    const lines = [`Running ${dry ? "dry runtime" : "model"} for ${target}`];
+    for (const event of result.events) {
+        if (event.type === "run.started") {
+            lines.push(`run.started: ${readString(event.payload.projectName) ?? "unknown project"}`);
+            continue;
+        }
+        if (event.type === "instructions.composed") {
+            lines.push(`instructions.composed: ${readCount(event.payload.sources)} source(s)`);
+            continue;
+        }
+        if (event.type === "tools.discovered") {
+            lines.push(`tools.discovered: ${readCount(event.payload.tools)} tool(s)`);
+            continue;
+        }
+        if (event.type === "model.request") {
+            lines.push(`model.request: ${readCount(event.payload.messages)} message(s)`);
+            continue;
+        }
+        if (event.type === "model.response") {
+            const content = readString(event.payload.content);
+            lines.push(`model.response: ${content?.slice(0, 80) ?? "no content"}`);
+            continue;
+        }
+        if (event.type === "assistant.output") {
+            lines.push(`assistant.output: ${readString(event.payload.content) ?? ""}`);
+            continue;
+        }
+        if (event.type === "tool.call") {
+            lines.push(`tool.call: ${readString(event.payload.toolName) ?? "unknown tool"}`);
+            continue;
+        }
+        if (event.type === "tool.result") {
+            lines.push(`tool.result: ${readString(event.payload.toolName) ?? "unknown tool"}`);
+            continue;
+        }
+        if (event.type === "approval.requested") {
+            lines.push(`approval.requested: ${readString(event.payload.toolName) ?? "unknown tool"}`);
+            continue;
+        }
+        if (event.type === "run.waiting") {
+            lines.push("run.waiting: approval required");
+            continue;
+        }
+        if (event.type === "run.completed") {
+            lines.push("run.completed: completed");
+            continue;
+        }
+        if (event.type === "run.failed") {
+            lines.push("run.failed: failed");
+            continue;
+        }
+        if (event.type === "run.cancelled") {
+            lines.push("run.cancelled: cancelled");
+            continue;
+        }
+        if (event.type === "run.error") {
+            lines.push(`run.error: ${readString(event.payload.message) ?? "runtime error"}`);
+        }
+    }
+    if (result.status === "waiting") {
+        lines.push(dry ? "Dry run waiting for approval." : "Run waiting for approval.");
+    }
+    else if (result.status === "failed") {
+        lines.push(dry ? "Dry run failed." : "Run failed.");
+    }
+    return lines;
+}

package/dist/format/runs.d.ts

@@ -0,0 +1,2 @@
+import type { RunSummary } from "@plico-ai/runtime";
+export declare function formatRunSummaries(target: string, databasePath: string, runs: RunSummary[]): string[];

package/dist/format/runs.js

@@ -0,0 +1,17 @@
+export function formatRunSummaries(target, databasePath, runs) {
+    const lines = [`Persisted runs for ${target} (${databasePath})`];
+    if (runs.length === 0) {
+        lines.push("No persisted runs found.");
+        return lines;
+    }
+    for (const run of runs) {
+        const summary = [
+            run.runId,
+            run.status,
+            run.projectName || "unknown project",
+            run.endedAt ?? "not ended",
+        ].join(" | ");
+        lines.push(summary);
+    }
+    return lines;
+}

package/dist/format/values.d.ts

@@ -0,0 +1,2 @@
+export declare function readCount(value: unknown): number;
+export declare function readString(value: unknown): string | undefined;

package/dist/format/values.js

@@ -0,0 +1,6 @@
+export function readCount(value) {
+    return Array.isArray(value) ? value.length : 0;
+}
+export function readString(value) {
+    return typeof value === "string" ? value : undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { validateProject } from "@plico-ai/core";

package/dist/index.js

@@ -0,0 +1 @@
+export { validateProject } from "@plico-ai/core";

package/dist/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveDatabasePath(target: string, dbPath: string | undefined): string;
+/** The Studio copied into the published package, else the workspace build when running from source. */
+export declare function findStudioPath(): string | undefined;
+export declare function ensureDatabaseExists(databasePath: string): Promise<void>;
+export declare function normalizeDisplayHost(host: string): string;

package/dist/paths.js

@@ -0,0 +1,35 @@
+import { existsSync, constants as fsConstants } from "node:fs";
+import { access } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+export function resolveDatabasePath(target, dbPath) {
+    return dbPath ?? join(target, ".plico", "plico.sqlite");
+}
+/** The Studio copied into the published package, else the workspace build when running from source. */
+export function findStudioPath() {
+    const bundled = join(dirname(fileURLToPath(import.meta.url)), "studio");
+    if (existsSync(join(bundled, "index.html")))
+        return bundled;
+    try {
+        const require = createRequire(import.meta.url);
+        return join(dirname(require.resolve("@plico-ai/studio/package.json")), "dist");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function ensureDatabaseExists(databasePath) {
+    try {
+        await access(databasePath, fsConstants.F_OK);
+    }
+    catch {
+        throw new Error(`Missing database: ${databasePath}`);
+    }
+}
+export function normalizeDisplayHost(host) {
+    if (host === "0.0.0.0" || host === "::") {
+        return "127.0.0.1";
+    }
+    return host;
+}

package/dist/quiet-sqlite-warning.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hides Node's one-line "SQLite is an experimental feature" notice from the `plico` command, so
+ * the commands that open the run database do not print it. Every other warning still prints.
+ * Only the bin calls this: a host app that mounts Plico owns its own process warnings.
+ */
+export declare function quietSqliteWarning(): void;

package/dist/quiet-sqlite-warning.js

@@ -0,0 +1,15 @@
+/**
+ * Hides Node's one-line "SQLite is an experimental feature" notice from the `plico` command, so
+ * the commands that open the run database do not print it. Every other warning still prints.
+ * Only the bin calls this: a host app that mounts Plico owns its own process warnings.
+ */
+export function quietSqliteWarning() {
+    const emitWarning = process.emitWarning.bind(process);
+    process.emitWarning = ((warning, ...rest) => {
+        const message = typeof warning === "string" ? warning : warning.message;
+        const type = typeof rest[0] === "string" ? rest[0] : warning.name;
+        if (type === "ExperimentalWarning" && /^SQLite is an experimental feature/.test(message))
+            return;
+        emitWarning(warning, ...rest);
+    });
+}

package/dist/script-file.d.ts

@@ -0,0 +1,2 @@
+import { type DryRunScriptStep } from "@plico-ai/runtime";
+export declare function loadDryRunScript(scriptPath: string): Promise<DryRunScriptStep[]>;

package/dist/script-file.js

@@ -0,0 +1,13 @@
+import { readFile } from "node:fs/promises";
+import { normalizeScript } from "@plico-ai/runtime";
+import { errorMessage } from "./errors.js";
+export async function loadDryRunScript(scriptPath) {
+    try {
+        const raw = await readFile(scriptPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return normalizeScript(parsed);
+    }
+    catch (error) {
+        throw new Error(`Unable to parse dry run script ${scriptPath}: ${errorMessage(error)}`);
+    }
+}