@letterstory/cli 0.1.1 → 0.2.1

package/lib/commands/strategy.mjs

@@ -0,0 +1,209 @@
+// `strategy` (company profile, positioning, competitors, sitemap import) and
+// `onboarding` (checklist status/step). Ported from phantomstory-cli's strategy.ts,
+// which registers `onboarding` as its own top-level command alongside `strategy` —
+// mirrored here as two exported handlers for the same reason.
+
+import { CliError } from "../client.mjs";
+import {
+	flagStr,
+	requireFlag,
+	requirePositional,
+	printResult,
+	compact,
+	flagList,
+	ok,
+	readBodyInput,
+} from "./shared.mjs";
+
+export async function cmdStrategy(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "company":
+			return strategyCompany(rest);
+		case "positioning":
+			return strategyPositioning(rest);
+		case "competitors":
+			return strategyCompetitors(rest);
+		case "sitemap":
+			return strategySitemap(rest);
+		default:
+			throw new CliError(
+				`Unknown strategy subcommand: ${sub ?? "(none)"}. Try: company, positioning, competitors, sitemap`
+			);
+	}
+}
+
+// -- company -------------------------------------------------------------
+
+async function strategyCompany(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "get":
+			return companyGet(rest);
+		case "set":
+			return companySet(rest);
+		default:
+			throw new CliError(`Unknown strategy company subcommand: ${sub ?? "(none)"}. Try: get, set`);
+	}
+}
+
+async function companyGet(ctx) {
+	const { client, flags, io } = ctx;
+	const result = await client.callTool("get_company_info", {});
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function companySet(ctx) {
+	const { client, flags, io } = ctx;
+	const args = compact({ name: flagStr(flags.name), domain: flagStr(flags.domain) });
+	// The API clears the manifesto with an empty string, which compact() would drop —
+	// so set it explicitly whenever the user supplied a source (text or file).
+	const manifesto = flagStr(flags.manifesto);
+	const manifestoFile = flagStr(flags["manifesto-file"]);
+	if (manifesto !== undefined || manifestoFile !== undefined) {
+		args.manifesto = manifesto ?? readBodyInput({ file: manifestoFile }) ?? "";
+	}
+	if (Object.keys(args).length === 0) {
+		throw new CliError('Nothing to set — pass --name/--domain/--manifesto (empty --manifesto "" clears it).');
+	}
+	const result = await client.callTool("set_company_info", args);
+	ok(ctx, "Company profile updated.");
+	printResult(io, flags, result);
+	return 0;
+}
+
+// -- positioning -----------------------------------------------------------
+
+async function strategyPositioning(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "get":
+			return positioningGet(rest);
+		case "set":
+			return positioningSet(rest);
+		default:
+			throw new CliError(`Unknown strategy positioning subcommand: ${sub ?? "(none)"}. Try: get, set`);
+	}
+}
+
+async function positioningGet(ctx) {
+	const { client, flags, io } = ctx;
+	const result = await client.callTool("get_positioning", {});
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function positioningSet(ctx) {
+	const { client, flags, io } = ctx;
+	const topics = flagList(flags.topic);
+	const stances = flagList(flags.stance);
+	const avoid = flagList(flags.avoid);
+	// The API clears a list with an explicit empty array (which compact() keeps).
+	const args = compact({
+		priority_topics: flags["clear-topics"] ? [] : topics.length ? topics : undefined,
+		stances: flags["clear-stances"] ? [] : stances.length ? stances : undefined,
+		avoid_topics: flags["clear-avoid"] ? [] : avoid.length ? avoid : undefined,
+	});
+	if (Object.keys(args).length === 0) {
+		throw new CliError("Pass at least one --topic/--stance/--avoid (or a --clear-* flag).");
+	}
+	const result = await client.callTool("set_positioning", args);
+	ok(ctx, "Positioning updated.");
+	printResult(io, flags, result);
+	return 0;
+}
+
+// -- competitors -------------------------------------------------------------
+
+async function strategyCompetitors(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "list":
+		case "ls":
+			return competitorsList(rest);
+		case "add":
+			return competitorsAdd(rest);
+		default:
+			throw new CliError(`Unknown strategy competitors subcommand: ${sub ?? "(none)"}. Try: list, add`);
+	}
+}
+
+async function competitorsList(ctx) {
+	const { client, flags, io } = ctx;
+	const result = await client.callTool("list_competitors", {});
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function competitorsAdd(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const name = requirePositional(positionals, 0, "name");
+	const domain = requirePositional(positionals, 1, "domain");
+	const result = await client.callTool("add_competitor", { name, domain });
+	ok(ctx, `Added competitor ${name}.`);
+	printResult(io, flags, result);
+	return 0;
+}
+
+// -- sitemap -------------------------------------------------------------
+
+async function strategySitemap(ctx) {
+	const { client, flags, io } = ctx;
+	const collection = requireFlag(flags, "collection");
+	const url = requireFlag(flags, "url");
+	const sub = flagList(flags.sub);
+	const args = compact({
+		collection_id: collection,
+		sitemap_url: url,
+		sitemap_urls: sub.length ? sub : undefined,
+		url_pattern: flagStr(flags.pattern),
+	});
+	const result = await client.callTool("import_sitemap", args);
+	ok(ctx, "Sitemap import started.");
+	printResult(io, flags, result);
+	return 0;
+}
+
+// --- onboarding ---------------------------------------------------------
+
+export async function cmdOnboarding(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "status":
+			return onboardingStatus(rest);
+		case "step":
+			return onboardingStep(rest);
+		default:
+			throw new CliError(`Unknown onboarding subcommand: ${sub ?? "(none)"}. Try: status, step`);
+	}
+}
+
+async function onboardingStatus(ctx) {
+	const { client, flags, io } = ctx;
+	const result = await client.callTool("get_onboarding_status", {});
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function onboardingStep(ctx) {
+	const { client, flags, io } = ctx;
+	const args = compact({
+		current_step: flagStr(flags.current),
+		complete_step: flagStr(flags.complete),
+		skip_step: flagStr(flags.skip),
+		status: flagStr(flags.status),
+	});
+	if (Object.keys(args).length === 0) {
+		throw new CliError("Pass --current/--complete/--skip/--status.");
+	}
+	const result = await client.callTool("set_onboarding_step", args);
+	ok(ctx, "Onboarding updated.");
+	printResult(io, flags, result);
+	return 0;
+}

package/lib/commands.mjs

@@ -1,323 +1,16 @@
-// Command handlers. Each takes a ctx { client, positionals, flags, io } and returns
-// a process exit code. Handlers do their own printing through io (so poll progress
-// streams live), and throw CliError for anything the user needs to fix.
-
-import { LetterstoryClient, CliError, resolveConfig, writeConfigFile, clearConfigFile, configPath } from "./client.mjs";
-
-// --- small helpers ----------------------------------------------------------
-
-// A flag with no value parses to `true`; coerce that back to undefined so a bare
-// `--name` reads as "missing", not the string "true".
-function flagStr(v) {
-	return typeof v === "string" ? v : undefined;
-}
-
-function flagNum(v) {
-	const s = flagStr(v);
-	if (s === undefined) return undefined;
-	const n = Number(s);
-	if (!Number.isFinite(n)) throw new CliError(`Expected a number, got "${s}"`);
-	return n;
-}
-
-function requireFlag(flags, name) {
-	const v = flagStr(flags[name]);
-	if (v === undefined) throw new CliError(`Missing required --${name}`);
-	return v;
-}
-
-function requirePositional(positionals, index, label) {
-	const v = positionals[index];
-	if (v === undefined) throw new CliError(`Missing required <${label}>`);
-	return v;
-}
-
-function printResult(io, flags, value, formatter) {
-	if (flags.json || !formatter) {
-		io.log(JSON.stringify(value, null, 2));
-	} else {
-		io.log(formatter(value));
-	}
-}
-
-function formatDeployment(d) {
-	const lines = [
-		`${d.name}  [${d.deployment_id}]`,
-		`  status:     ${d.status}${d.phase ? ` · ${d.phase}` : ""}`,
-		`  theme:      ${d.theme}`,
-		`  collection: ${d.collection_id ?? "(none)"}`,
-	];
-	if (d.url) lines.push(`  url:        ${d.url}`);
-	if (d.domain) lines.push(`  domain:     ${d.domain}`);
-	if (d.last_error) lines.push(`  error:      ${d.last_error}`);
-	return lines.join("\n");
-}
-
-// Poll get_deployment until the blog reaches a terminal state. Emits a line only
-// when status/phase changes so the output reads as progress, not a firehose.
-async function pollUntilTerminal(client, id, io) {
-	const maxPolls = io.maxPolls ?? 90;
-	const interval = io.pollIntervalMs ?? 4000;
-	let last = "";
-	for (let i = 0; i < maxPolls; i++) {
-		const d = await client.callTool("get_deployment", { deployment_id: id });
-		if (d.status === "live" || d.status === "error") return d;
-		const line = `${d.status}${d.phase ? ` · ${d.phase}` : ""}`;
-		if (line !== last) {
-			io.log(`  … ${line}`);
-			last = line;
-		}
-		await io.sleep(interval);
-	}
-	return {
-		status: "error",
-		last_error: `Timed out waiting for it to go live. Check: letterstory deploy get ${id}`,
-		url: null,
-	};
-}
-
-// --- auth / config ----------------------------------------------------------
-
-export async function cmdLogin(ctx) {
-	const { flags, io } = ctx;
-	const key = requireFlag(flags, "key");
-	const url = flagStr(flags.url);
-	if (!key.startsWith("lb_")) {
-		io.error("Warning: Letterstory API keys usually start with 'lb_'. Saving anyway.");
-	}
-	const saved = { key, ...(url ? { url } : {}) };
-	const path = writeConfigFile(saved);
-	io.log(`Saved credentials to ${path}`);
-
-	// Verify the key works (and report the tool count) without failing the save if
-	// the network is down — a saved-but-unverified key is still usable later.
-	try {
-		const resolved = resolveConfig({ url, key });
-		const client = new LetterstoryClient({ url: resolved.url, key: resolved.key });
-		const tools = await client.listTools();
-		io.log(`Authenticated to ${resolved.url} — ${tools.length} tools available.`);
-		return 0;
-	} catch (err) {
-		io.error(`Saved, but could not verify the key: ${err.message}`);
-		return 0;
-	}
-}
-
-export function cmdLogout(ctx) {
-	const path = clearConfigFile();
-	ctx.io.log(`Cleared credentials at ${path}`);
-	return 0;
-}
-
-export function cmdConfig(ctx) {
-	const { config, io, flags } = ctx;
-	const masked = config.key ? `${config.key.slice(0, 6)}…${config.key.slice(-4)}` : "(none)";
-	const value = {
-		url: config.url,
-		key: masked,
-		key_source: config.keySource,
-		config_file: configPath(),
-	};
-	if (flags.json) {
-		io.log(JSON.stringify(value, null, 2));
-	} else {
-		io.log(`url:         ${value.url}`);
-		io.log(`key:         ${value.key} (from ${value.key_source})`);
-		io.log(`config file: ${value.config_file}`);
-	}
-	return 0;
-}
-
-// --- discovery / generic passthrough ----------------------------------------
-
-export async function cmdTools(ctx) {
-	const { client, io, flags } = ctx;
-	const doc = await client.discover();
-	const tools = doc.tools ?? [];
-	if (flags.json) {
-		io.log(JSON.stringify(tools, null, 2));
-		return 0;
-	}
-	io.log(`${tools.length} tools available at ${client.url}:\n`);
-	for (const t of tools) io.log(`  ${t.name} — ${t.description ?? ""}`);
-	return 0;
-}
-
-// Escape hatch: call any tool by name. Args come from --args '<json>', or from
-// individual string flags (everything after the tool name). Keeps the whole
-// manifest reachable without a bespoke subcommand per tool.
-export async function cmdCall(ctx) {
-	const { client, positionals, flags, io } = ctx;
-	const name = requirePositional(positionals, 0, "tool");
-	let args = {};
-	if (flags.args !== undefined) {
-		try {
-			args = JSON.parse(flagStr(flags.args) ?? "");
-		} catch {
-			throw new CliError(`--args must be a JSON object, e.g. --args '{"name":"My Blog"}'`);
-		}
-	} else {
-		for (const [k, v] of Object.entries(flags)) {
-			if (k === "json" || k === "url" || k === "key") continue;
-			args[k] = v;
-		}
-	}
-	const result = await client.callTool(name, args);
-	io.log(typeof result === "string" ? result : JSON.stringify(result, null, 2));
-	return 0;
-}
-
-// --- deployments (phantom blogs) --------------------------------------------
-
-export async function cmdDeploy(ctx) {
-	const sub = ctx.positionals[0];
-	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
-	switch (sub) {
-		case "create":
-			return deployCreate(rest);
-		case "list":
-			return deployList(rest);
-		case "get":
-		case "status":
-			return deployGet(rest);
-		case "rebuild":
-			return deployRebuild(rest);
-		case "diagnostics":
-			return deployDiagnostics(rest);
-		case "delete":
-			return deployDelete(rest);
-		default:
-			throw new CliError(
-				`Unknown deploy subcommand: ${sub ?? "(none)"}. Try: create, list, get, rebuild, diagnostics, delete`
-			);
-	}
-}
-
-async function deployCreate(ctx) {
-	const { client, flags, io } = ctx;
-	const name = requireFlag(flags, "name");
-	const args = { name };
-	const description = flagStr(flags.description);
-	const theme = flagStr(flags.theme);
-	const collection = flagStr(flags.collection);
-	if (description !== undefined) args.description = description;
-	if (theme !== undefined) args.theme = theme;
-	if (collection !== undefined) args.collection_id = collection;
-
-	const created = await client.callTool("create_deployment", args);
-	io.log(`Created deployment ${created.deployment_id} (${created.status})`);
-
-	if (flags["no-wait"]) {
-		io.log(`Provisioning in the background. Poll with: letterstory deploy get ${created.deployment_id}`);
-		return 0;
-	}
-
-	const final = await pollUntilTerminal(client, created.deployment_id, io);
-	if (final.status === "live") {
-		io.log(`\n✓ Live at ${final.url}`);
-		return 0;
-	}
-	io.error(`\n✗ Deployment ${final.status}: ${final.last_error ?? "unknown error"}`);
-	return 1;
-}
-
-async function deployList(ctx) {
-	const { client, flags, io } = ctx;
-	const limit = flagNum(flags.limit);
-	const result = await client.callTool("list_deployments", limit !== undefined ? { limit } : {});
-	const items = result.items ?? [];
-	if (flags.json) {
-		io.log(JSON.stringify(result, null, 2));
-		return 0;
-	}
-	if (items.length === 0) {
-		io.log("No deployments yet. Create one with: letterstory deploy create --name <name>");
-		return 0;
-	}
-	for (const d of items) {
-		io.log(`${d.status.padEnd(13)} ${d.deployment_id}  ${d.name}${d.url ? `  ${d.url}` : ""}`);
-	}
-	return 0;
-}
-
-async function deployGet(ctx) {
-	const { client, positionals, flags, io } = ctx;
-	const id = requirePositional(positionals, 0, "deployment-id");
-	const d = await client.callTool("get_deployment", { deployment_id: id });
-	printResult(io, flags, d, formatDeployment);
-	return 0;
-}
-
-async function deployRebuild(ctx) {
-	const { client, positionals, io } = ctx;
-	const id = requirePositional(positionals, 0, "deployment-id");
-	await client.callTool("rebuild_deployment", { deployment_id: id });
-	io.log(`Rebuild started for ${id}. New published content will appear once the build finishes.`);
-	return 0;
-}
-
-async function deployDiagnostics(ctx) {
-	const { client, positionals, io } = ctx;
-	const id = requirePositional(positionals, 0, "deployment-id");
-	const diag = await client.callTool("get_deployment_diagnostics", { deployment_id: id });
-	io.log(JSON.stringify(diag, null, 2));
-	return 0;
-}
-
-async function deployDelete(ctx) {
-	const { client, positionals, flags, io } = ctx;
-	const id = requirePositional(positionals, 0, "deployment-id");
-	if (!flags.yes) {
-		io.error(`This tears down the blog's site and revokes its content key (the collection is kept).`);
-		io.error(`Re-run with --yes to confirm: letterstory deploy delete ${id} --yes`);
-		return 1;
-	}
-	await client.callTool("delete_deployment", { deployment_id: id });
-	io.log(`Deleted deployment ${id}.`);
-	return 0;
-}
-
-// --- custom domains ---------------------------------------------------------
-
-export async function cmdDomain(ctx) {
-	const sub = ctx.positionals[0];
-	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
-	switch (sub) {
-		case "check":
-			return domainCheck(rest);
-		case "buy":
-			return domainBuy(rest);
-		default:
-			throw new CliError(`Unknown domain subcommand: ${sub ?? "(none)"}. Try: check, buy`);
-	}
-}
-
-async function domainCheck(ctx) {
-	const { client, positionals, flags, io } = ctx;
-	const domain = requirePositional(positionals, 0, "domain");
-	const quote = await client.callTool("check_domain", { domain });
-	if (flags.json) {
-		io.log(JSON.stringify(quote, null, 2));
-		return 0;
-	}
-	io.log(`${domain}`);
-	io.log(`  available:   ${quote.available}`);
-	if (quote.price !== undefined) io.log(`  price:       $${quote.price}`);
-	io.log(`  purchasable: ${quote.purchasable}`);
-	return 0;
-}
-
-// No confirm gate: the app's BuyDomainDialog charges on a single "Get this domain"
-// click, and the CLI mirrors the app's user-facing flow. The spend is bounded on the
-// server, not by a client prompt — `buy_domain` is server-priced and hard-capped
-// (≤2 domains/org, <$30, blog must be live with no domain yet).
-async function domainBuy(ctx) {
-	const { client, positionals, flags, io } = ctx;
-	const id = requirePositional(positionals, 0, "deployment-id");
-	const domain = requirePositional(positionals, 1, "domain");
-	const result = await client.callTool("buy_domain", { deployment_id: id, domain });
-	io.log(`Purchase started for ${domain}. Attach + DNS run in the background.`);
-	io.log(`Poll with: letterstory deploy get ${id}`);
-	if (flags.json) io.log(JSON.stringify(result, null, 2));
-	return 0;
-}
+// Command handlers, split into focused modules under ./commands/*.mjs as the surface
+// grew past a single-file's worth of clarity (auth, discovery, deploy/domain, posts,
+// collections, flows, connectors, strategy, insights). This file re-exports
+// everything so `cli.mjs` — and any test importing straight from "commands.mjs" —
+// keep a single, stable import path regardless of how the implementation is split.
+
+export * from "./commands/auth.mjs";
+export * from "./commands/discovery.mjs";
+export * from "./commands/deploy.mjs";
+export * from "./commands/mcp.mjs";
+export * from "./commands/posts.mjs";
+export * from "./commands/collections.mjs";
+export * from "./commands/flows.mjs";
+export * from "./commands/connectors.mjs";
+export * from "./commands/strategy.mjs";
+export * from "./commands/insights.mjs";