@letterstory/cli 0.1.1 → 0.2.0

package/lib/commands/posts.mjs

@@ -0,0 +1,122 @@
+// `posts` (draft/read/publish articles) and `published` (the frozen public view).
+// Ported from phantomstory-cli's posts.ts — same tool calls, same shape, adapted to
+// this CLI's flag/positional/io conventions (no commander, no color).
+
+import { CliError } from "../client.mjs";
+import {
+	flagStr,
+	flagNum,
+	requireFlag,
+	requirePositional,
+	printResult,
+	compact,
+	ok,
+	readBodyInput,
+} from "./shared.mjs";
+
+export async function cmdPosts(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "list":
+		case "ls":
+			return postsList(rest);
+		case "show":
+			return postsShow(rest);
+		case "new":
+			return postsNew(rest);
+		case "publish":
+			return postsPublish(rest);
+		case "unpublish":
+			return postsUnpublish(rest);
+		default:
+			throw new CliError(
+				`Unknown posts subcommand: ${sub ?? "(none)"}. Try: list, show, new, publish, unpublish`
+			);
+	}
+}
+
+async function postsList(ctx) {
+	const { client, flags, io } = ctx;
+	const args = compact({ limit: flagNum(flags.limit), collection_id: flagStr(flags.collection) });
+	const result = await client.callTool("list_articles", args);
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function postsShow(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const id = requirePositional(positionals, 0, "article-id");
+	const result = await client.callTool("get_article", { article_id: id });
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function postsNew(ctx) {
+	const { client, flags, io } = ctx;
+	const title = requireFlag(flags, "title");
+	const collection = requireFlag(flags, "collection");
+	const body = readBodyInput(flags);
+	if (!body) throw new CliError("Provide --body or --file <path>.");
+	const result = await client.callTool("ingest_article", { title, body, collection_id: collection });
+	ok(ctx, `Created draft "${title}".`);
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function postsPublish(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const id = requirePositional(positionals, 0, "article-id");
+	const result = await client.callTool("publish_article", { article_id: id });
+	ok(ctx, "Published.");
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function postsUnpublish(ctx) {
+	const { client, positionals, flags, io } = ctx;
+	const id = requirePositional(positionals, 0, "article-id");
+	const result = await client.callTool("unpublish_article", { article_id: id });
+	ok(ctx, "Unpublished.");
+	printResult(io, flags, result);
+	return 0;
+}
+
+// --- published (frozen public view) -----------------------------------------
+
+export async function cmdPublished(ctx) {
+	const sub = ctx.positionals[0];
+	const rest = { ...ctx, positionals: ctx.positionals.slice(1) };
+	switch (sub) {
+		case "list":
+		case "ls":
+			return publishedList(rest);
+		case "show":
+			return publishedShow(rest);
+		default:
+			throw new CliError(`Unknown published subcommand: ${sub ?? "(none)"}. Try: list, show`);
+	}
+}
+
+async function publishedList(ctx) {
+	const { client, flags, io } = ctx;
+	const args = compact({
+		limit: flagNum(flags.limit),
+		collection_id: flagStr(flags.collection),
+		format: flagStr(flags.format),
+	});
+	const result = await client.callTool("list_published", args);
+	printResult(io, flags, result);
+	return 0;
+}
+
+async function publishedShow(ctx) {
+	const { client, flags, io } = ctx;
+	const id = flagStr(flags.id);
+	const slug = flagStr(flags.slug);
+	if (id === undefined && slug === undefined) throw new CliError("Pass --id or --slug.");
+	const args = compact({ article_id: id, slug, format: flagStr(flags.format) });
+	const result = await client.callTool("get_published", args);
+	printResult(io, flags, result);
+	return 0;
+}

package/lib/commands/shared.mjs

@@ -0,0 +1,95 @@
+// Helpers shared by every command module: flag/positional readers, JSON-vs-formatted
+// output, and the --quiet-aware success line. Kept dependency-free like the rest of
+// the CLI — no formatting library, just small string builders.
+
+import { readFileSync } from "node:fs";
+import { CliError } from "../client.mjs";
+
+// A flag with no value parses to `true`; coerce that back to undefined so a bare
+// `--name` reads as "missing", not the string "true". A repeated flag (see cli.mjs's
+// parseArgs) parses to an array — also "missing" for a single-value read.
+export function flagStr(v) {
+	return typeof v === "string" ? v : undefined;
+}
+
+export 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;
+}
+
+export function flagBool(v) {
+	return v === true;
+}
+
+// Repeatable flags (e.g. `--topic a --topic b`) accumulate into an array in
+// parseArgs; a single occurrence stays a plain string. Normalize both to a list.
+export function flagList(v) {
+	if (v === undefined) return [];
+	if (Array.isArray(v)) return v.filter((x) => typeof x === "string");
+	return typeof v === "string" ? [v] : [];
+}
+
+export function requireFlag(flags, name) {
+	const v = flagStr(flags[name]);
+	if (v === undefined) throw new CliError(`Missing required --${name}`);
+	return v;
+}
+
+export function requirePositional(positionals, index, label) {
+	const v = positionals[index];
+	if (v === undefined) throw new CliError(`Missing required <${label}>`);
+	return v;
+}
+
+// Drop undefined entries so callTool args only carry fields the user actually set.
+export function compact(obj) {
+	const out = {};
+	for (const [k, v] of Object.entries(obj)) {
+		if (v !== undefined) out[k] = v;
+	}
+	return out;
+}
+
+export function printResult(io, flags, value, formatter) {
+	if (flags.json || !formatter) {
+		io.log(JSON.stringify(value, null, 2));
+	} else {
+		io.log(formatter(value));
+	}
+}
+
+// A success line that stays quiet under --quiet or --json (scripting doesn't want
+// chatter mixed into a parseable stream). Existing commands (deploy/domain) print
+// directly through io.log and are intentionally left alone; this gate is for the
+// new command groups only.
+export function ok(ctx, message) {
+	if (ctx.flags.quiet || ctx.flags.json) return;
+	ctx.io.log(message);
+}
+
+// Read a text body from --body, or --file (a path, or "-" for stdin). Returns
+// undefined if neither flag was given, so callers can decide whether that's an error.
+export function readBodyInput(flags) {
+	const body = flagStr(flags.body);
+	if (body !== undefined) return body;
+	const file = flagStr(flags.file);
+	if (file === undefined) return undefined;
+	if (file === "-") {
+		if (process.stdin.isTTY) {
+			throw new CliError("No data on stdin. Pipe input in, or use --body/--file <path> instead of --file -.");
+		}
+		try {
+			return readFileSync(0, "utf8");
+		} catch (err) {
+			throw new CliError(`Could not read stdin: ${err.message}`);
+		}
+	}
+	try {
+		return readFileSync(file, "utf8");
+	} catch (err) {
+		throw new CliError(`Could not read --file ${file}: ${err.message}`);
+	}
+}

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;
+}