howone 0.1.53 → 0.2.0

package/bin/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { createRequire } from "node:module";
 import { execFile } from "node:child_process";
-import { readdir, rename, stat, writeFile } from "node:fs/promises";
+import { readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
@@ -62,6 +62,18 @@ async function main() {
 		await runDeploy(command.options);
 		return;
 	}
+	if (scope === "capabilities" || scope === "capability" || scope === "caps") {
+		await runCapabilitiesCommand(subcommand, rest, command.options);
+		return;
+	}
+	if (scope === "skills" || scope === "skill") {
+		await runSkillsCommand(subcommand, rest, command.options);
+		return;
+	}
+	if (scope === "run") {
+		await runCapabilityRun(compact([subcommand, ...rest]), command.options);
+		return;
+	}
 	if (scope === "ai" && subcommand === "run") {
 		await runAiRun(rest, command.options);
 		return;
@@ -87,9 +99,22 @@ function parseCommand(args) {
 			"next",
 			"force",
 			"yes",
-			"json"
+			"json",
+			"stream"
 		],
-		string: ["template", "cwd"],
+		string: [
+			"template",
+			"cwd",
+			"scope",
+			"input",
+			"output",
+			"prompt",
+			"api-url",
+			"token",
+			"status",
+			"reason"
+		],
+		number: ["limit"],
 		configuration: { "camel-case-expansion": false }
 	});
 	return {
@@ -103,6 +128,16 @@ function parseCommand(args) {
 			yes: Boolean(parsed.yes),
 			json: Boolean(parsed.json),
 			cwd: typeof parsed.cwd === "string" ? parsed.cwd : void 0,
+			scope: typeof parsed.scope === "string" ? parsed.scope : void 0,
+			input: typeof parsed.input === "string" ? parsed.input : void 0,
+			output: typeof parsed.output === "string" ? parsed.output : void 0,
+			prompt: typeof parsed.prompt === "string" ? parsed.prompt : void 0,
+			apiUrl: typeof parsed["api-url"] === "string" ? parsed["api-url"] : void 0,
+			token: typeof parsed.token === "string" ? parsed.token : void 0,
+			stream: Boolean(parsed.stream),
+			status: typeof parsed.status === "string" ? parsed.status : void 0,
+			limit: typeof parsed.limit === "number" && Number.isFinite(parsed.limit) ? parsed.limit : void 0,
+			reason: typeof parsed.reason === "string" ? parsed.reason : void 0,
 			help: Boolean(parsed.help) || hasHelp,
 			version: Boolean(parsed.version) || hasVersion
 		}
@@ -182,6 +217,244 @@ async function runAiRun(pathArgs, options) {
 	}
 	printPending("howone ai run", result.message ?? "AI run is not implemented yet.");
 }
+async function runCapabilitiesCommand(subcommand, pathArgs, options) {
+	if (!subcommand || subcommand === "search") {
+		const query = pathArgs.join(" ").trim();
+		if (!query) throw new CliError("E_QUERY_REQUIRED", "Search query is required.");
+		await runCapabilitySearch(query, options);
+		return;
+	}
+	if (subcommand === "list") {
+		await runCapabilityList(options);
+		return;
+	}
+	if (subcommand === "inspect" || subcommand === "show") {
+		const ref = pathArgs[0];
+		if (!ref) throw new CliError("E_CAPABILITY_REF_REQUIRED", "Capability reference is required.");
+		await runCapabilityInspect(ref, options);
+		return;
+	}
+	if (subcommand === "proposals") {
+		await runCapabilityProposals(options);
+		return;
+	}
+	if (subcommand === "apply") {
+		const proposalId = pathArgs[0];
+		if (!proposalId) throw new CliError("E_PROPOSAL_ID_REQUIRED", "Capability proposal id is required.");
+		await runCapabilityProposalAction("apply", proposalId, options);
+		return;
+	}
+	if (subcommand === "reject") {
+		const proposalId = pathArgs[0];
+		if (!proposalId) throw new CliError("E_PROPOSAL_ID_REQUIRED", "Capability proposal id is required.");
+		await runCapabilityProposalAction("reject", proposalId, options);
+		return;
+	}
+	throw new CliError("E_COMMAND_UNKNOWN", `Unknown capabilities command: ${["capabilities", subcommand].join(" ")}`);
+}
+async function runSkillsCommand(subcommand, pathArgs, options) {
+	const ref = pathArgs[0];
+	if (subcommand === "export") {
+		if (!ref) throw new CliError("E_SKILL_REF_REQUIRED", "Skill reference is required.");
+		await runSkillProjection("export", ref, options);
+		return;
+	}
+	if (subcommand === "install") {
+		if (!ref) throw new CliError("E_SKILL_REF_REQUIRED", "Skill reference is required.");
+		await runSkillProjection("install", ref, options);
+		return;
+	}
+	if (subcommand === "publish") {
+		if (!ref) throw new CliError("E_SKILL_REF_REQUIRED", "Skill reference is required.");
+		await runSkillProjection("publish", ref, options);
+		return;
+	}
+	throw new CliError("E_COMMAND_UNKNOWN", `Unknown skills command: ${["skills", subcommand].filter(Boolean).join(" ")}`);
+}
+async function runCapabilitySearch(query, options) {
+	const params = new URLSearchParams({ q: query });
+	if (options.scope) params.set("scope", options.scope);
+	await printRegistryResult("capabilities search", await callHowoneRegistryApi(`/api/capabilities/search?${params}`, {
+		options,
+		requireAuth: options.scope !== "public"
+	}), options);
+}
+async function runCapabilityList(options) {
+	const params = new URLSearchParams();
+	if (options.scope) params.set("scope", options.scope);
+	await printRegistryResult("capabilities list", await callHowoneRegistryApi(`/api/capabilities${params.size ? `?${params}` : ""}`, {
+		options,
+		requireAuth: options.scope !== "public"
+	}), options);
+}
+async function runCapabilityInspect(ref, options) {
+	const result = await callHowoneRegistryApi(`/api/capabilities/${encodeURIComponent(ref)}`, {
+		options,
+		requireAuth: options.scope !== "public"
+	});
+	await printRegistryResult(`capabilities inspect ${ref}`, result, options);
+}
+async function runCapabilityProposals(options) {
+	const params = new URLSearchParams();
+	if (options.status) params.set("status", options.status);
+	if (options.limit) params.set("limit", String(options.limit));
+	await printRegistryResult("capabilities proposals", await callHowoneRegistryApi(`/api/capabilities/proposals${params.size ? `?${params}` : ""}`, {
+		options,
+		requireAuth: true
+	}), options);
+}
+async function runCapabilityProposalAction(action, proposalId, options) {
+	const result = await callHowoneRegistryApi(`/api/capabilities/proposals/${encodeURIComponent(proposalId)}/${action}`, {
+		options,
+		requireAuth: true,
+		init: {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(action === "reject" ? { reason: options.reason } : {})
+		}
+	});
+	await printRegistryResult(`capabilities ${action} ${proposalId}`, result, options);
+}
+async function runCapabilityRun(pathArgs, options) {
+	const actionRef = pathArgs[0];
+	if (!actionRef && !options.prompt) throw new CliError("E_ACTION_REF_REQUIRED", "Capability action reference is required, or use --prompt for query-based routing.");
+	const input = await readCapabilityRunInput(options);
+	const body = {
+		...actionRef ? { actionRef } : {},
+		...options.prompt ? { prompt: options.prompt } : {},
+		input,
+		stream: Boolean(options.stream)
+	};
+	const result = await callHowoneRegistryApi("/api/capabilities/run", {
+		options,
+		requireAuth: true,
+		init: {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		}
+	});
+	await printRegistryResult(actionRef ? `run ${actionRef}` : "run query", result, options);
+}
+async function runSkillProjection(action, ref, options) {
+	const method = action === "export" ? "GET" : "POST";
+	const result = await callHowoneRegistryApi(`/api/capabilities/skills/${encodeURIComponent(ref)}/${action}`, {
+		options,
+		requireAuth: action !== "export",
+		init: { method }
+	});
+	await printRegistryResult(`skills ${action} ${ref}`, result, options);
+}
+async function readCapabilityRunInput(options) {
+	if (!options.input) return {};
+	const raw = options.input.trim();
+	const content = raw.startsWith("{") || raw.startsWith("[") ? raw : await readFile(path.resolve(options.cwd ?? process.cwd(), raw), "utf-8");
+	try {
+		const parsed = JSON.parse(content);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new CliError("E_INPUT_INVALID", "Capability input must be a JSON object.");
+		return parsed;
+	} catch (error) {
+		if (error instanceof CliError) throw error;
+		throw new CliError("E_INPUT_INVALID", error instanceof Error ? error.message : "Invalid JSON input.");
+	}
+}
+function resolveHowoneApiUrl(options) {
+	return (options.apiUrl ?? process.env.HOWONE_API_URL ?? process.env.NEXT_PUBLIC_SERVER_URL ?? "https://howone.dev").replace(/\/+$/, "");
+}
+function resolveHowoneApiToken(options) {
+	return options.token ?? process.env.HOWONE_API_TOKEN ?? process.env.HOWONE_AGENT_TOKEN;
+}
+async function callHowoneRegistryApi(apiPath, args) {
+	const token = resolveHowoneApiToken(args.options);
+	if (args.requireAuth && !token) throw new CliError("E_AUTH_REQUIRED", "Set HOWONE_API_TOKEN or pass --token to access private/workspace capabilities.");
+	const url = `${resolveHowoneApiUrl(args.options)}${apiPath.startsWith("/") ? apiPath : `/${apiPath}`}`;
+	const headers = new Headers(args.init?.headers);
+	if (token) headers.set("Authorization", `Bearer ${token}`);
+	headers.set("Accept", args.options.stream ? "text/event-stream, application/json" : "application/json");
+	const response = await fetch(url, {
+		...args.init,
+		headers
+	});
+	const contentType = response.headers.get("content-type") ?? "";
+	if (args.options.stream && contentType.includes("text/event-stream")) return readSseResponse(response);
+	const text = await response.text();
+	const body = text ? parseJsonOrText(text) : null;
+	if (!response.ok) throw new CliError("E_API_REQUEST_FAILED", `HowOne API request failed: HTTP ${response.status}`, {
+		status: response.status,
+		body
+	});
+	return body;
+}
+async function readSseResponse(response) {
+	if (!response.ok) throw new CliError("E_API_REQUEST_FAILED", `HowOne API request failed: HTTP ${response.status}`);
+	if (!response.body) return {
+		ok: true,
+		events: []
+	};
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	const events = [];
+	let buffer = "";
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let boundary = buffer.indexOf("\n\n");
+		while (boundary >= 0) {
+			const chunk = buffer.slice(0, boundary).trim();
+			buffer = buffer.slice(boundary + 2);
+			if (chunk) {
+				events.push(chunk);
+				console.log(chunk);
+			}
+			boundary = buffer.indexOf("\n\n");
+		}
+	}
+	const tail = buffer.trim();
+	if (tail) {
+		events.push(tail);
+		console.log(tail);
+	}
+	return {
+		ok: true,
+		events
+	};
+}
+function parseJsonOrText(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+async function printRegistryResult(command, result, options) {
+	if (options.output) await writeFile(path.resolve(options.cwd ?? process.cwd(), options.output), `${JSON.stringify(result, null, 2)}\n`, "utf-8");
+	if (options.json || options.output) {
+		if (!options.output) console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	console.log(formatPanel(pc.bold(command), [formatRegistrySummary(result)]));
+}
+function formatRegistrySummary(result) {
+	if (typeof result === "string") return result;
+	if (!result || typeof result !== "object") return String(result);
+	const record = result;
+	const data = record.data ?? record.results ?? record.capabilities ?? record.actions;
+	if (Array.isArray(data)) {
+		if (!data.length) return "No capabilities found.";
+		return data.slice(0, 12).map((item) => {
+			if (!item || typeof item !== "object") return `- ${String(item)}`;
+			const row = item;
+			const name = row.name ?? row.title ?? row.slug ?? row.actionRef ?? row.proposalSlug ?? row.id ?? "capability";
+			const description = row.description ?? row.summary ?? row.reason ?? row.status;
+			return `- ${String(name)}${description ? `: ${String(description)}` : ""}`;
+		}).join("\n");
+	}
+	const name = record.name ?? record.title ?? record.slug ?? record.actionRef ?? record.proposalSlug ?? record.id;
+	const description = record.description ?? record.summary ?? record.reason ?? record.status;
+	if (name || description) return [name ? String(name) : void 0, description ? String(description) : void 0].filter(Boolean).join("\n");
+	return JSON.stringify(result, null, 2);
+}
 async function resolveCreatePlan(pathArgs, options, cwd, isInteractive) {
 	const template = resolveTemplateOption(options);
 	const projectName = pathArgs[0] === "template" ? pathArgs[1] : pathArgs[0];
@@ -417,6 +690,18 @@ function printHelp(pathArgs) {
 		printReservedHelp("howone deploy", "Deploy support is reserved and not implemented yet.");
 		return;
 	}
+	if (topic === "capabilities" || topic === "capabilities search") {
+		printCapabilitiesHelp();
+		return;
+	}
+	if (topic === "skills") {
+		printSkillsHelp();
+		return;
+	}
+	if (topic === "run") {
+		printRunHelp();
+		return;
+	}
 	if (topic === "ai" || topic === "ai run") {
 		printReservedHelp("howone ai run [aiId]", "AI run support is reserved and not implemented yet.");
 		return;
@@ -429,6 +714,11 @@ function printRootHelp() {
 		"",
 		pc.bold("Commands"),
 		formatCommand("init app [name]", "Create an app from a template"),
+		formatCommand("capabilities search <query>", "Search callable HowOne capabilities"),
+		formatCommand("capabilities inspect <ref>", "Inspect a capability package or action"),
+		formatCommand("capabilities proposals", "List generated capability proposals"),
+		formatCommand("run <package.action>", "Run a callable capability action"),
+		formatCommand("skills export <ref>", "Export a skill projection for a capability"),
 		formatCommand("create", "Reserved placeholder"),
 		formatCommand("deploy", "Reserved placeholder"),
 		formatCommand("ai run [aiId]", "Reserved placeholder"),
@@ -439,8 +729,10 @@ function printRootHelp() {
 		"",
 		pc.bold("Examples"),
 		`  ${pc.cyan("howone init app my-app --template vite")}`,
-		`  ${pc.cyan("howone deploy")}`,
-		`  ${pc.cyan("howone ai run generateImage")}`
+		`  ${pc.cyan("howone capabilities search \"海报生成\" --scope public")}`,
+		`  ${pc.cyan("howone capabilities proposals --status pending_review")}`,
+		`  ${pc.cyan("howone run poster-generator.createPoster --input input.json --output result.json")}`,
+		`  ${pc.cyan("howone run --prompt \"帮我生成一张 AI 发布会海报\" --stream")}`
 	]));
 }
 function printInitHelp() {
@@ -469,6 +761,71 @@ function printReservedHelp(command, description) {
 		`${pc.yellow("Pending")} This command is available as a stable placeholder.`
 	]));
 }
+function printCapabilitiesHelp() {
+	console.log(formatPanel(`${pc.bold("HowOne capabilities")}`, [
+		`${pc.dim("Usage")}    howone capabilities <command> [options]`,
+		"",
+		pc.bold("Commands"),
+		formatCommand("search <query>", "Search private, workspace, installed, or public capabilities"),
+		formatCommand("list", "List capabilities in a scope"),
+		formatCommand("inspect <ref>", "Inspect package/action schemas and runtime bindings"),
+		formatCommand("proposals", "List generated proposals for the current user"),
+		formatCommand("apply <proposalId>", "Apply a generated proposal to the registry"),
+		formatCommand("reject <proposalId>", "Reject a generated proposal"),
+		"",
+		pc.bold("Options"),
+		formatCommand("--scope <scope>", "private, workspace, installed, public, or global"),
+		formatCommand("--status <status>", "Filter proposal list by status"),
+		formatCommand("--limit <number>", "Limit result count"),
+		formatCommand("--reason <text>", "Reason for rejecting a proposal"),
+		formatCommand("--api-url <url>", "HowOne registry API origin"),
+		formatCommand("--token <token>", "Agent API token; defaults to HOWONE_API_TOKEN"),
+		formatCommand("--json", "Print machine-readable JSON output"),
+		"",
+		pc.bold("Examples"),
+		`  ${pc.cyan("howone capabilities search \"海报生成\" --scope public")}`,
+		`  ${pc.cyan("howone capabilities inspect poster-generator.createPoster")}`,
+		`  ${pc.cyan("howone capabilities proposals --status pending_review")}`,
+		`  ${pc.cyan("howone capabilities apply 00000000-0000-0000-0000-000000000000")}`
+	]));
+}
+function printRunHelp() {
+	console.log(formatPanel(`${pc.bold("Run a capability")}`, [
+		`${pc.dim("Usage")}    howone run <package.action> [options]`,
+		"",
+		pc.bold("Options"),
+		formatCommand("--input <json|file>", "JSON object or path to JSON input file"),
+		formatCommand("--prompt <text>", "Natural-language query routed through the registry"),
+		formatCommand("--output <file>", "Write JSON result to a file"),
+		formatCommand("--stream", "Request SSE and print events as they arrive"),
+		formatCommand("--api-url <url>", "HowOne registry API origin"),
+		formatCommand("--token <token>", "Agent API token; defaults to HOWONE_API_TOKEN"),
+		formatCommand("--json", "Print machine-readable JSON output"),
+		"",
+		pc.bold("Examples"),
+		`  ${pc.cyan("howone run poster-generator.createPoster --input input.json")}`,
+		`  ${pc.cyan("howone run --prompt \"帮我生成一张 AI 发布会海报\" --stream")}`
+	]));
+}
+function printSkillsHelp() {
+	console.log(formatPanel(`${pc.bold("HowOne skill projections")}`, [
+		`${pc.dim("Usage")}    howone skills <command> <ref> [options]`,
+		"",
+		pc.bold("Commands"),
+		formatCommand("export <ref>", "Export an agent-facing skill artifact"),
+		formatCommand("install <ref>", "Install a public or workspace skill projection"),
+		formatCommand("publish <ref>", "Request publication of a capability skill projection"),
+		"",
+		pc.bold("Options"),
+		formatCommand("--api-url <url>", "HowOne registry API origin"),
+		formatCommand("--token <token>", "Agent API token; defaults to HOWONE_API_TOKEN"),
+		formatCommand("--json", "Print machine-readable JSON output"),
+		"",
+		pc.bold("Examples"),
+		`  ${pc.cyan("howone skills export poster-generator")}`,
+		`  ${pc.cyan("howone skills install poster-generator")}`
+	]));
+}
 function printPending(command, message) {
 	console.log(formatPanel(pc.bold(command), [`${pc.yellow("Pending")} ${message}`]));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "howone",
-  "version": "0.1.53",
+  "version": "0.2.0",
   "private": false,
   "description": "HowOne command line tools for creating app templates.",
   "type": "module",