@danypops/papyrus 0.44.9 → 0.44.11

package/src/cli/rules-command.ts

@@ -0,0 +1,220 @@
+import type { CommandContext } from "@stricli/core";
+import { buildApplication, buildCommand, buildRouteMap, numberParser } from "@stricli/core";
+import type { PapyrusClient } from "../client.ts";
+import type { OperationName } from "../service.ts";
+import { artifactLabel, type CliArtifact } from "./shared.ts";
+import { runStricliToString } from "./stricli-run.ts";
+
+type RulesClient = Pick<PapyrusClient, "call">;
+
+interface RulesContext extends CommandContext {
+	readonly client: RulesClient;
+	readonly json: boolean;
+	/** The caller's own project root -- distinct from any --project-root flag; only `injectable` uses this. */
+	readonly callerProjectRoot: string;
+}
+
+function parseStringArray(value: string): string[] {
+	const parsed = JSON.parse(value) as unknown;
+	if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string")) throw new Error("value must be a JSON string array");
+	return parsed as string[];
+}
+
+function parseObject(value: string): Record<string, unknown> {
+	const parsed = JSON.parse(value) as unknown;
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("value must be a JSON object");
+	return parsed as Record<string, unknown>;
+}
+
+function render(this: RulesContext, result: unknown, human: string): void {
+	this.process.stdout.write(this.json ? JSON.stringify(result) : human);
+}
+
+const createCommand = buildCommand({
+	func: async function (
+		this: RulesContext,
+		flags: {
+			title: string;
+			body?: string;
+			condition?: string;
+			ruleAction?: string;
+			severity?: string;
+			labelsJson?: string[];
+			extraJson?: Record<string, unknown>;
+			projectRoot?: string;
+		},
+	) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.create", {
+			title: flags.title,
+			body: flags.body,
+			condition: flags.condition,
+			rule_action: flags.ruleAction,
+			severity: flags.severity,
+			labels: flags.labelsJson,
+			extra: flags.extraJson,
+			project_root: flags.projectRoot,
+		});
+		render.call(this, artifact, `Created rule: ${artifactLabel(artifact)}`);
+	},
+	parameters: {
+		flags: {
+			title: { brief: "Rule title", kind: "parsed", parse: String, placeholder: "text" },
+			body: { brief: "Rule body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			condition: { brief: "When this rule applies", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			ruleAction: { brief: "What the rule requires", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			severity: { brief: "block|warn|info", kind: "parsed", parse: String, placeholder: "severity", optional: true },
+			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+			extraJson: { brief: "JSON object of extra fields", kind: "parsed", parse: parseObject, placeholder: "json", optional: true },
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+	},
+	docs: { brief: "Create a Rule" },
+});
+
+const listCommand = buildCommand({
+	func: async function (this: RulesContext, flags: { status?: string; text?: string; limit?: number; projectRoot?: string }) {
+		const rows = await this.client.call<Record<string, unknown>, CliArtifact[]>("rules.list", {
+			status: flags.status,
+			text: flags.text,
+			limit: flags.limit,
+			project_root: flags.projectRoot,
+		});
+		render.call(this, rows, rows.length === 0 ? "No rules found." : rows.map((row) => artifactLabel(row)).join("\n"));
+	},
+	parameters: {
+		flags: {
+			status: { brief: "Filter by status", kind: "parsed", parse: String, placeholder: "status", optional: true },
+			text: { brief: "Substring match against title/body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			limit: { brief: "Maximum rules to return", kind: "parsed", parse: numberParser, optional: true },
+			projectRoot: { brief: "Project scope", kind: "parsed", parse: String, placeholder: "path", optional: true },
+		},
+	},
+	docs: { brief: "List Rules" },
+});
+
+const assignProjectCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string, projectRoot?: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.assign_project", {
+			id,
+			project_root: projectRoot,
+		});
+		render.call(this, artifact, projectRoot ? `Assigned ${id} to ${projectRoot}` : `Unscoped ${id}`);
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [
+				{ brief: "Rule id", parse: String, placeholder: "id" },
+				{ brief: "New project scope, omit to unscope", parse: String, placeholder: "project-root", optional: true },
+			],
+		},
+	},
+	docs: { brief: "Reassign a Rule's project scope, or unscope it" },
+});
+
+const showCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.show", { id });
+		render.call(this, artifact, `${artifactLabel(artifact)}\n\n${artifact.body ?? ""}`);
+	},
+	parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] } },
+	docs: { brief: "Show one Rule" },
+});
+
+const previewCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string) {
+		const preview = await this.client.call<Record<string, unknown>, string>("rules.preview", { id });
+		render.call(this, preview, preview);
+	},
+	parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] } },
+	docs: { brief: "Render a Rule's own condition/action/body preview text" },
+});
+
+function buildEnableDisableCommand(action: "enable" | "disable") {
+	return buildCommand({
+		func: async function (this: RulesContext, _flags: Record<string, never>, id: string) {
+			const artifact = await this.client.call<Record<string, unknown>, CliArtifact>(`rules.${action}` as OperationName, { id });
+			render.call(this, artifact, artifactLabel(artifact));
+		},
+		parameters: { flags: {}, positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] } },
+		docs: { brief: `${action[0]!.toUpperCase()}${action.slice(1)} a Rule` },
+	});
+}
+
+const gateCommand = buildCommand({
+	func: async function (this: RulesContext, _flags: Record<string, never>, id: string, taskId: string) {
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.gate", { id, task_id: taskId });
+		render.call(this, artifact, `Gated ${taskId} with rule ${artifactLabel(artifact)}`);
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [
+				{ brief: "Rule id", parse: String, placeholder: "rule-id" },
+				{ brief: "Task id to gate", parse: String, placeholder: "task-id" },
+			],
+		},
+	},
+	docs: { brief: "Attach a Rule as a gate condition on a Task" },
+});
+
+const injectableCommand = buildCommand({
+	func: async function (this: RulesContext) {
+		const rows = await this.client.call<Record<string, unknown>, CliArtifact[]>("rules.injectable", {
+			project_root: this.callerProjectRoot,
+		});
+		render.call(this, rows, rows.length === 0 ? "No injectable rules." : rows.map((row) => row.title).join("\n"));
+	},
+	parameters: { flags: {} },
+	docs: { brief: "List Rules currently injectable into the agent system prompt for this project" },
+});
+
+const updateCommand = buildCommand({
+	func: async function (this: RulesContext, flags: { title?: string; body?: string; labelsJson?: string[] }, id: string) {
+		if (flags.title === undefined && flags.body === undefined && flags.labelsJson === undefined)
+			throw new Error("rules update requires --title, --body, or --labels-json");
+		const artifact = await this.client.call<Record<string, unknown>, CliArtifact>("rules.update", {
+			id,
+			title: flags.title,
+			body: flags.body,
+			labels: flags.labelsJson,
+		});
+		render.call(this, artifact, artifactLabel(artifact));
+	},
+	parameters: {
+		flags: {
+			title: { brief: "New title", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			body: { brief: "New body", kind: "parsed", parse: String, placeholder: "text", optional: true },
+			labelsJson: { brief: "JSON string array of labels", kind: "parsed", parse: parseStringArray, placeholder: "json", optional: true },
+		},
+		positional: { kind: "tuple", parameters: [{ brief: "Rule id", parse: String, placeholder: "id" }] },
+	},
+	docs: { brief: "Change a Rule's title/body/labels" },
+});
+
+const app = buildApplication(
+	buildRouteMap({
+		routes: {
+			create: createCommand,
+			list: listCommand,
+			"assign-project": assignProjectCommand,
+			show: showCommand,
+			preview: previewCommand,
+			enable: buildEnableDisableCommand("enable"),
+			disable: buildEnableDisableCommand("disable"),
+			gate: gateCommand,
+			injectable: injectableCommand,
+			update: updateCommand,
+		},
+		docs: { brief: "Rule operations" },
+	}),
+	{ name: "rules", scanner: { caseStyle: "allow-kebab-for-camel" } },
+);
+
+export async function runRulesCli(args: string[], client: RulesClient, projectRoot: string = process.cwd()): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((arg) => arg !== "--json");
+	return runStricliToString(app, positional, { client, json, callerProjectRoot: projectRoot });
+}

package/src/cli/session-identity-command.ts

@@ -0,0 +1,58 @@
+import type { CommandContext } from "@stricli/core";
+import { buildApplication, buildCommand, buildRouteMap } from "@stricli/core";
+import type { PapyrusClient } from "../client.ts";
+import { runStricliToString } from "./stricli-run.ts";
+
+type SessionIdentityClient = Pick<PapyrusClient, "call">;
+
+interface SessionIdentityContext extends CommandContext {
+	readonly client: SessionIdentityClient;
+	readonly json: boolean;
+}
+
+function render(this: SessionIdentityContext, result: unknown): void {
+	this.process.stdout.write(this.json ? JSON.stringify(result) : JSON.stringify(result, null, 2));
+}
+
+const registerCommand = buildCommand({
+	func: async function (this: SessionIdentityContext, flags: { sessionId: string }) {
+		const result = await this.client.call<Record<string, unknown>, { sessionId: string; secret: string }>("session.register", {
+			session_id: flags.sessionId,
+		});
+		render.call(this, result);
+	},
+	parameters: {
+		flags: {
+			sessionId: { brief: "Session id to register", kind: "parsed", parse: String, placeholder: "id" },
+		},
+	},
+	docs: { brief: "Register a session identity, receiving back a secret for later mutations" },
+});
+
+const releaseCommand = buildCommand({
+	func: async function (this: SessionIdentityContext, flags: { sessionId: string; sessionSecret?: string }) {
+		const result = await this.client.call<Record<string, unknown>, { released: boolean }>("session.release", {
+			session_id: flags.sessionId,
+			...(flags.sessionSecret ? { session_secret: flags.sessionSecret } : {}),
+		});
+		render.call(this, result);
+	},
+	parameters: {
+		flags: {
+			sessionId: { brief: "Session id to release", kind: "parsed", parse: String, placeholder: "id" },
+			sessionSecret: { brief: "Secret returned at registration", kind: "parsed", parse: String, placeholder: "secret", optional: true },
+		},
+	},
+	docs: { brief: "Release a registered session identity" },
+});
+
+const app = buildApplication(
+	buildRouteMap({ routes: { register: registerCommand, release: releaseCommand }, docs: { brief: "Session identity operations" } }),
+	{ name: "session", scanner: { caseStyle: "allow-kebab-for-camel" } },
+);
+
+export async function runSessionIdentityCli(args: string[], client: SessionIdentityClient): Promise<string> {
+	const json = args.includes("--json");
+	const positional = args.filter((arg) => arg !== "--json");
+	return runStricliToString(app, positional, { client, json });
+}

package/src/cli/shared.ts

@@ -0,0 +1,5 @@
+export type CliArtifact = { id: string; alias: string; title: string; status: string; body?: string };
+
+export function artifactLabel(artifact: CliArtifact): string {
+	return `${artifact.alias} ${artifact.title}`;
+}

package/src/cli/stricli-run.ts

@@ -0,0 +1,30 @@
+import type { Application, CommandContext } from "@stricli/core";
+import { run } from "@stricli/core";
+
+/**
+ * Every run*Cli export keeps the pre-Stricli (args, client) => Promise<string> contract so
+ * test/cli-parity.test.ts and cli.ts's main() dispatch don't need to change per migrated command.
+ * Stricli itself never throws for a user-facing failure (invalid flag, unknown route) -- it
+ * writes to context.process.stderr and sets context.process.exitCode instead -- so this captures
+ * both in memory and converts a nonzero exit code back into a thrown Error to match every other
+ * run*Cli function's own contract.
+ */
+export async function runStricliToString<CONTEXT extends CommandContext>(
+	app: Application<CONTEXT>,
+	args: string[],
+	contextWithoutProcess: Omit<CONTEXT, "process">,
+): Promise<string> {
+	const chunks: string[] = [];
+	const errors: string[] = [];
+	const process: {
+		stdout: { write: (text: string) => void };
+		stderr: { write: (text: string) => void };
+		exitCode?: number | string | null;
+	} = {
+		stdout: { write: (text: string) => chunks.push(text) },
+		stderr: { write: (text: string) => errors.push(text) },
+	};
+	await run(app, args, { ...contextWithoutProcess, process } as CONTEXT);
+	if (process.exitCode) throw new Error(errors.join("").trim() || `command failed with exit code ${process.exitCode}`);
+	return chunks.join("");
+}