slimwiki 0.1.0

package/dist/index.js

@@ -0,0 +1,782 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import open from "open";
+import { setTimeout as sleep } from "timers/promises";
+
+// src/lib/api-client.ts
+var createApiClient = (opts) => {
+  const { apiBase, token } = opts;
+  const base = apiBase.replace(/\/$/, "");
+  const buildUrl = (path, query) => {
+    const url = new URL(path.startsWith("/") ? `${base}${path}` : path);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null && v !== "") {
+          url.searchParams.set(k, String(v));
+        }
+      }
+    }
+    return url.toString();
+  };
+  const request = async (method, path, init) => {
+    const headers = {
+      Accept: "application/json"
+    };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const fetchInit = { method, headers };
+    if (init?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      fetchInit.body = JSON.stringify(init.body);
+    }
+    const url = buildUrl(path, init?.query);
+    const res = await fetch(url, fetchInit);
+    if (res.status === 204) return void 0;
+    const contentType = res.headers.get("content-type") ?? "";
+    const isJson = contentType.includes("application/json");
+    const payload = isJson ? await res.json().catch(() => ({})) : await res.text();
+    if (!res.ok) {
+      const message = typeof payload === "object" && (payload?.error || payload?.message) || typeof payload === "string" && payload || `HTTP ${res.status} ${res.statusText}`;
+      if (res.status === 401) {
+        throw new Error(
+          "Not authenticated. Run `slimwiki auth login` or set SLIMWIKI_TOKEN."
+        );
+      }
+      throw new Error(message);
+    }
+    return payload;
+  };
+  return {
+    apiBase: base,
+    request,
+    get: (path, query) => request("GET", path, { query }),
+    post: (path, body) => request("POST", path, { body }),
+    delete: (path) => request("DELETE", path)
+  };
+};
+var fromAuth = (auth) => createApiClient({ apiBase: auth.apiBase, token: auth.token });
+
+// src/lib/config.ts
+import envPaths from "env-paths";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var PATHS = envPaths("slimwiki", { suffix: "" });
+var CREDENTIALS_FILE = join(PATHS.config, "credentials.json");
+var DEFAULT_API_BASE = "https://slimwiki.com";
+var credentialsPath = () => CREDENTIALS_FILE;
+var readCredentials = async () => {
+  try {
+    const raw = await readFile(CREDENTIALS_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+};
+var writeCredentials = async (creds) => {
+  await mkdir(dirname(CREDENTIALS_FILE), { recursive: true });
+  await writeFile(CREDENTIALS_FILE, JSON.stringify(creds, null, 2), {
+    mode: 384
+  });
+};
+var deleteCredentials = async () => {
+  try {
+    await rm(CREDENTIALS_FILE);
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
+};
+var resolveAuth = async (opts = {}) => {
+  const envToken = process.env.SLIMWIKI_TOKEN;
+  if (envToken) {
+    return {
+      apiBase: opts.apiBaseOverride ?? process.env.SLIMWIKI_API_BASE ?? DEFAULT_API_BASE,
+      token: envToken,
+      fromEnv: true,
+      credentials: null
+    };
+  }
+  const creds = await readCredentials();
+  if (!creds?.token) return null;
+  return {
+    apiBase: opts.apiBaseOverride ?? creds.apiBase ?? DEFAULT_API_BASE,
+    token: creds.token,
+    fromEnv: false,
+    credentials: creds
+  };
+};
+var requireAuth = async (opts = {}) => {
+  const auth = await resolveAuth(opts);
+  if (!auth) {
+    throw new Error(
+      "Not authenticated. Run `slimwiki auth login` or set SLIMWIKI_TOKEN."
+    );
+  }
+  return auth;
+};
+
+// src/lib/output.ts
+var isHuman = (cmd) => {
+  return Boolean(cmd.optsWithGlobals().human);
+};
+var apiBaseOverride = (cmd) => {
+  const v = cmd.optsWithGlobals().apiBase;
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+};
+var writeResult = (cmd, value, human) => {
+  if (isHuman(cmd) && human) {
+    process.stdout.write(human(value));
+    if (!human(value).endsWith("\n")) process.stdout.write("\n");
+    return;
+  }
+  process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+};
+var writeError = (err) => {
+  const message = err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
+  process.stderr.write(JSON.stringify({ error: message }) + "\n");
+};
+var exitWithError = (err, code = 1) => {
+  writeError(err);
+  process.exit(code);
+};
+
+// src/commands/auth.ts
+var POLL_TIMEOUT_PADDING_MS = 5e3;
+var runLogin = async (cmd, opts) => {
+  const apiBase = opts.apiBase ?? apiBaseOverride(cmd) ?? DEFAULT_API_BASE;
+  const client = createApiClient({ apiBase });
+  const init = await client.post("/api/v1/auth/cli/init");
+  process.stderr.write(
+    `
+Open this URL in your browser to authorize the SlimWiki CLI:
+
+  ${init.verificationUrl}
+
+Verification code (must match the one shown in the browser):
+
+  ${init.userCode}
+
+`
+  );
+  open(init.verificationUrl).catch(() => void 0);
+  const intervalMs = Math.max(1, init.pollInterval) * 1e3;
+  const deadline = Date.now() + init.expiresIn * 1e3 + POLL_TIMEOUT_PADDING_MS;
+  let approved = null;
+  while (Date.now() < deadline) {
+    const result = await client.post("/api/v1/auth/cli/poll", {
+      deviceCode: init.deviceCode
+    });
+    if (result.status === "approved") {
+      approved = result;
+      break;
+    }
+    if (result.status === "expired") {
+      throw new Error(
+        "CLI authorization code has expired. Please re-run `slimwiki auth login`."
+      );
+    }
+    await sleep(intervalMs);
+  }
+  if (!approved) {
+    throw new Error(
+      "Timed out waiting for browser approval. Please re-run `slimwiki auth login`."
+    );
+  }
+  await writeCredentials({
+    apiBase,
+    token: approved.token,
+    expiresAt: approved.expiresAt,
+    user: approved.user,
+    account: approved.account,
+    wiki: approved.wiki
+  });
+  writeResult(
+    cmd,
+    {
+      status: "ok",
+      user: approved.user,
+      account: approved.account,
+      wiki: approved.wiki,
+      apiBase,
+      credentialsPath: credentialsPath()
+    },
+    (v) => `Logged in as ${v.user.email}
+` + (v.account ? `Account: ${v.account.slug}
+` : "") + (v.wiki ? `Wiki:    ${v.wiki.slug}
+` : "") + `Saved to ${v.credentialsPath}
+`
+  );
+};
+var runLogout = async (cmd) => {
+  const auth = await resolveAuth({ apiBaseOverride: apiBaseOverride(cmd) });
+  if (auth?.token && !auth.fromEnv) {
+    const client = fromAuth(auth);
+    await client.post("/api/auth/sign-out").catch(() => void 0);
+  }
+  await deleteCredentials();
+  writeResult(cmd, { status: "ok" }, () => "Logged out.\n");
+};
+var runStatus = async (cmd) => {
+  const auth = await resolveAuth({ apiBaseOverride: apiBaseOverride(cmd) });
+  if (!auth) {
+    writeResult(
+      cmd,
+      { authenticated: false },
+      () => "Not authenticated. Run `slimwiki auth login`.\n"
+    );
+    return;
+  }
+  let user = auth.credentials?.user ?? null;
+  let account = auth.credentials?.account ?? null;
+  let wiki = auth.credentials?.wiki ?? null;
+  if (auth.fromEnv) {
+    try {
+      const me = await fromAuth(auth).get("/api/v1/users/me");
+      user = me.user;
+      account = me.account ?? null;
+      wiki = me.wiki ?? null;
+    } catch {
+    }
+  }
+  writeResult(
+    cmd,
+    {
+      authenticated: true,
+      apiBase: auth.apiBase,
+      source: auth.fromEnv ? "env" : "credentials-file",
+      user,
+      account,
+      wiki
+    },
+    (v) => `Authenticated as ${v.user?.email ?? "(unknown)"}
+API:     ${v.apiBase}
+Source:  ${v.source}
+` + (v.account ? `Account: ${v.account.slug}
+` : "") + (v.wiki ? `Wiki:    ${v.wiki.slug}
+` : "")
+  );
+};
+var registerAuthCommands = (program2) => {
+  const auth = program2.command("auth").description("Authenticate the CLI");
+  auth.command("login").description("Open a browser to authorize the CLI").option(
+    "--api-base <url>",
+    "SlimWiki API base URL (default https://slimwiki.com)"
+  ).action(async function() {
+    try {
+      await runLogin(this, this.opts());
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+  auth.command("logout").description("Revoke the CLI session and delete saved credentials").action(async function() {
+    try {
+      await runLogout(this);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+  auth.command("status").description("Show the cached session details").action(async function() {
+    try {
+      await runStatus(this);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+};
+
+// src/commands/account.ts
+var formatTable = (rows) => {
+  if (rows.length === 0) return "No accounts found.\n";
+  const widths = {
+    slug: Math.max(4, ...rows.map((r) => r.slug.length)),
+    name: Math.max(4, ...rows.map((r) => (r.name ?? "").length))
+  };
+  const lines = [
+    `${"slug".padEnd(widths.slug)}  ${"name".padEnd(widths.name)}`
+  ];
+  for (const r of rows) {
+    lines.push(
+      `${r.slug.padEnd(widths.slug)}  ${(r.name ?? "").padEnd(widths.name)}`
+    );
+  }
+  return lines.join("\n") + "\n";
+};
+var registerAccountCommands = (program2) => {
+  const account = program2.command("account").description("Inspect SlimWiki accounts");
+  account.command("list").description("List the accounts the current user belongs to").action(async function() {
+    try {
+      const auth = await requireAuth({ apiBaseOverride: apiBaseOverride(this) });
+      const client = fromAuth(auth);
+      const rows = await client.get("/api/v1/accounts");
+      const stripped = rows.map((r) => ({
+        slug: r.slug,
+        name: r.name ?? null
+      }));
+      writeResult(this, stripped, formatTable);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+};
+
+// src/lib/selectors.ts
+var findAccountBySlug = async (client, slug) => {
+  const accounts = await client.get("/api/v1/accounts");
+  const match = accounts.find((a) => a.slug === slug);
+  if (!match) {
+    throw new Error(
+      `Account not found for slug "${slug}". Run \`slimwiki account list\` to see available accounts.`
+    );
+  }
+  return match;
+};
+var findWikiInAccount = async (client, accountId, slug) => {
+  const wikis = await client.get("/api/v1/wikis", {
+    accountId
+  });
+  const match = wikis.find((w) => w.slug === slug);
+  if (!match) {
+    throw new Error(
+      `Wiki not found for slug "${slug}" in this account. Run \`slimwiki wiki list\` to see available wikis.`
+    );
+  }
+  return match;
+};
+var resolveAccount = async (auth, client, flags) => {
+  const slug = flags.account ?? process.env.SLIMWIKI_ACCOUNT_SLUG ?? auth.credentials?.account?.slug;
+  if (slug) return findAccountBySlug(client, slug);
+  const me = await client.get("/api/v1/users/me");
+  if (!me.account) {
+    throw new Error(
+      "No account is associated with this session. Use --account or run `slimwiki account list`."
+    );
+  }
+  return {
+    id: me.account.id,
+    slug: me.account.slug,
+    name: me.account.name ?? null
+  };
+};
+var resolveWiki = async (auth, client, flags, account) => {
+  const account_ = account ?? await resolveAccount(auth, client, flags);
+  const slug = flags.wiki ?? process.env.SLIMWIKI_WIKI_SLUG ?? auth.credentials?.wiki?.slug;
+  if (slug) return findWikiInAccount(client, account_.id, slug);
+  const me = await client.get("/api/v1/users/me");
+  if (me.wiki && me.account) {
+    return {
+      id: me.wiki.id,
+      slug: me.wiki.slug,
+      name: me.wiki.name ?? null,
+      accountId: me.account.id
+    };
+  }
+  throw new Error(
+    "No default wiki found for this account. Use --wiki or run `slimwiki wiki list`."
+  );
+};
+var resolveParent = async (client, wikiId, reference) => {
+  const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    reference
+  );
+  if (isUuid) return reference;
+  const matches = await client.get(`/api/v1/pages/wiki/${wikiId}`, { archived: false });
+  const page = matches.pages.find(
+    (p) => p.slug === reference || p.pageHash === reference
+  );
+  if (!page) {
+    throw new Error(`Parent page not found for "${reference}".`);
+  }
+  return page.id;
+};
+
+// src/commands/wiki.ts
+var formatTable2 = (rows) => {
+  if (rows.length === 0) return "No wikis found.\n";
+  const widths = {
+    slug: Math.max(4, ...rows.map((r) => r.slug.length)),
+    name: Math.max(4, ...rows.map((r) => (r.name ?? "").length))
+  };
+  const lines = [
+    `${"slug".padEnd(widths.slug)}  ${"name".padEnd(widths.name)}`
+  ];
+  for (const r of rows) {
+    lines.push(
+      `${r.slug.padEnd(widths.slug)}  ${(r.name ?? "").padEnd(widths.name)}`
+    );
+  }
+  return lines.join("\n") + "\n";
+};
+var registerWikiCommands = (program2) => {
+  const wiki = program2.command("wiki").description("Inspect wikis");
+  wiki.command("list").description("List wikis in the current (or selected) account").option("--account <slug>", "Account slug").action(async function(opts) {
+    try {
+      const auth = await requireAuth({ apiBaseOverride: apiBaseOverride(this) });
+      const client = fromAuth(auth);
+      const account = await resolveAccount(auth, client, {
+        account: opts.account
+      });
+      const rows = await client.get("/api/v1/wikis", {
+        accountId: account.id
+      });
+      const stripped = rows.map((r) => ({
+        slug: r.slug,
+        name: r.name ?? null
+      }));
+      writeResult(this, stripped, formatTable2);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+};
+
+// src/commands/page.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/lib/tiptap-schema.ts
+import { z } from "zod";
+var HeadingAttrs = z.object({
+  level: z.union([z.literal(1), z.literal(2), z.literal(3)])
+});
+var ImageAttrs = z.object({
+  src: z.string().min(1),
+  alt: z.string().optional(),
+  title: z.string().optional()
+}).passthrough();
+var VideoAttrs = z.object({ src: z.string().min(1) }).passthrough();
+var AttachmentAttrs = z.object({ src: z.string().min(1).optional(), name: z.string().optional() }).passthrough();
+var CodeBlockAttrs = z.object({ language: z.string().nullable().optional() }).passthrough();
+var TaskItemAttrs = z.object({ checked: z.boolean().optional() }).passthrough();
+var MathAttrs = z.object({ latex: z.string() }).passthrough();
+var PageMentionAttrs = z.object({ pageId: z.string(), pageSlug: z.string().optional() }).passthrough();
+var LinkMarkAttrs = z.object({ href: z.string().min(1), target: z.string().optional() }).passthrough();
+var TextStyleAttrs = z.object({ color: z.string().optional() }).passthrough();
+var Mark = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("bold") }).passthrough(),
+  z.object({ type: z.literal("italic") }).passthrough(),
+  z.object({ type: z.literal("underline") }).passthrough(),
+  z.object({ type: z.literal("strike") }).passthrough(),
+  z.object({ type: z.literal("code") }).passthrough(),
+  z.object({ type: z.literal("highlight") }).passthrough(),
+  z.object({ type: z.literal("link"), attrs: LinkMarkAttrs }).passthrough(),
+  z.object({ type: z.literal("textStyle"), attrs: TextStyleAttrs.optional() }).passthrough()
+]);
+var Node = z.lazy(
+  () => z.union([
+    z.object({
+      type: z.literal("text"),
+      text: z.string(),
+      marks: z.array(Mark).optional()
+    }).passthrough(),
+    z.object({ type: z.literal("hardBreak") }).passthrough(),
+    z.object({
+      type: z.literal("paragraph"),
+      attrs: z.unknown().optional(),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("heading"),
+      attrs: HeadingAttrs,
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("blockquote"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("bulletList"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("orderedList"),
+      attrs: z.object({ start: z.number().optional() }).passthrough().optional(),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("listItem"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("taskList"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("taskItem"),
+      attrs: TaskItemAttrs.optional(),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("codeBlock"),
+      attrs: CodeBlockAttrs.optional(),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({ type: z.literal("horizontalRule") }).passthrough(),
+    z.object({ type: z.literal("image"), attrs: ImageAttrs }).passthrough(),
+    z.object({ type: z.literal("video"), attrs: VideoAttrs }).passthrough(),
+    z.object({ type: z.literal("attachment"), attrs: AttachmentAttrs }).passthrough(),
+    z.object({
+      type: z.literal("math"),
+      attrs: MathAttrs
+    }).passthrough(),
+    z.object({
+      type: z.literal("pageMention"),
+      attrs: PageMentionAttrs
+    }).passthrough(),
+    z.object({
+      type: z.literal("table"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("tableRow"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("tableCell"),
+      content: z.array(Node).optional()
+    }).passthrough(),
+    z.object({
+      type: z.literal("tableHeader"),
+      content: z.array(Node).optional()
+    }).passthrough()
+  ])
+);
+var TiptapDocSchema = z.object({
+  type: z.literal("doc"),
+  content: z.array(Node)
+}).passthrough();
+
+// src/commands/page.ts
+var readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+var parseDoc = (raw) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Could not parse JSON content: ${err?.message ?? "invalid JSON"}`);
+  }
+  const result = TiptapDocSchema.safeParse(parsed);
+  if (!result.success) {
+    const first = result.error.issues[0];
+    const path = first?.path?.length ? `at ${first.path.join(".")} ` : "";
+    throw new Error(
+      `Tiptap doc validation failed ${path}\u2014 ${first?.message ?? "schema mismatch"}`
+    );
+  }
+  return result.data;
+};
+var formatListTable = (payload) => {
+  const rows = "rows" in payload ? payload.rows : payload.pages;
+  if (rows.length === 0) return "No pages found.\n";
+  const widths = {
+    slug: Math.max(4, ...rows.map((r) => r.slug.length)),
+    title: Math.max(5, ...rows.map((r) => r.title.length))
+  };
+  const lines = [
+    `${"slug".padEnd(widths.slug)}  ${"title".padEnd(widths.title)}  pageHash`
+  ];
+  for (const r of rows) {
+    lines.push(
+      `${r.slug.padEnd(widths.slug)}  ${r.title.padEnd(widths.title)}  ${r.pageHash}`
+    );
+  }
+  lines.push(`
+Total: ${payload.total}`);
+  return lines.join("\n") + "\n";
+};
+var runList = async (cmd, opts) => {
+  const auth = await requireAuth({ apiBaseOverride: apiBaseOverride(cmd) });
+  const client = fromAuth(auth);
+  const wiki = await resolveWiki(auth, client, {
+    account: opts.account,
+    wiki: opts.wiki
+  });
+  const archived = opts.archived ?? false;
+  const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 20;
+  const offset = opts.offset ? Number.parseInt(opts.offset, 10) : 0;
+  if (opts.search) {
+    const raw = await client.get(
+      `/api/v1/pages/wiki/${wiki.id}/search`,
+      { q: opts.search, limit, offset, archived }
+    );
+    const result2 = {
+      rows: raw.rows.map(
+        (r) => ({
+          title: r.title,
+          slug: r.slug,
+          pageHash: r.pageHash,
+          updatedAt: r.updatedAt
+        })
+      ),
+      total: raw.total
+    };
+    writeResult(cmd, result2, formatListTable);
+    return;
+  }
+  const pageNumber = Math.max(1, Math.floor(offset / 20) + 1);
+  const result = await client.get(
+    `/api/v1/pages/wiki/${wiki.id}`,
+    { page: pageNumber, archived }
+  );
+  const sliceStart = offset - (pageNumber - 1) * 20;
+  const trimmed = result.pages.slice(sliceStart, sliceStart + limit).map((p) => ({
+    title: p.title,
+    slug: p.slug,
+    pageHash: p.pageHash,
+    updatedAt: p.updatedAt
+  }));
+  writeResult(
+    cmd,
+    { rows: trimmed, total: result.total },
+    formatListTable
+  );
+};
+var runGet = async (cmd, identifier, opts) => {
+  const auth = await requireAuth({ apiBaseOverride: apiBaseOverride(cmd) });
+  const client = fromAuth(auth);
+  const wiki = await resolveWiki(auth, client, opts);
+  const isUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    identifier
+  );
+  const isPageHash = /^[A-Za-z0-9_-]{12}$/.test(identifier);
+  const query = {};
+  if (isUuid) query.id = identifier;
+  else if (isPageHash) query.pageHash = identifier;
+  else query.slug = identifier;
+  const page = await client.get(
+    `/api/v1/pages/${wiki.id}`,
+    query
+  );
+  writeResult(
+    cmd,
+    page,
+    (p) => `${p.title}
+${"-".repeat(p.title.length)}
+slug:     ${p.slug}
+pageHash: ${p.pageHash}
+archived: ${p.archived ? "yes" : "no"}
+updated:  ${p.updatedAt}
+
+[content omitted in --human view; use JSON output for full body]
+`
+  );
+};
+var runCreate = async (cmd, opts) => {
+  const sources = [opts.file, opts.content, opts.stdin].filter(
+    (v) => v !== void 0 && v !== false
+  );
+  if (sources.length !== 1) {
+    throw new Error(
+      "Provide exactly one of --file <path>, --content <jsonString>, or --stdin."
+    );
+  }
+  let raw;
+  if (opts.file) raw = await readFile2(opts.file, "utf8");
+  else if (opts.content) raw = opts.content;
+  else raw = await readStdin();
+  const doc = parseDoc(raw);
+  const auth = await requireAuth({ apiBaseOverride: apiBaseOverride(cmd) });
+  const client = fromAuth(auth);
+  const wiki = await resolveWiki(auth, client, {
+    account: opts.account,
+    wiki: opts.wiki
+  });
+  let parentId;
+  if (opts.parent) parentId = await resolveParent(client, wiki.id, opts.parent);
+  const page = await client.post(
+    `/api/v1/pages?updateIndexTree=true${parentId ? `&parentId=${parentId}` : ""}`,
+    {
+      wikiId: wiki.id,
+      title: opts.title,
+      slug: "",
+      content: doc.content
+    }
+  );
+  writeResult(
+    cmd,
+    page,
+    (p) => `Created "${p.title}"
+slug:     ${p.slug}
+pageHash: ${p.pageHash}
+`
+  );
+};
+var registerPageCommands = (program2) => {
+  const page = program2.command("page").description("Inspect and create pages");
+  page.command("list").description("List pages in a wiki, optionally filtered by --search").option("--account <slug>", "Account slug").option("--wiki <slug>", "Wiki slug").option("--search <query>", "Filter pages whose title or content matches the query").option("--archived", "Include archived pages", false).option("--limit <n>", "Maximum number of rows to return").option("--offset <n>", "Number of rows to skip").action(async function(opts) {
+    try {
+      await runList(this, opts);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+  page.command("get <identifier>").description("Fetch one page by slug, pageHash, or id (full content included)").option("--account <slug>", "Account slug").option("--wiki <slug>", "Wiki slug").action(async function(identifier, opts) {
+    try {
+      await runGet(this, identifier, opts);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+  page.command("create").description("Create a page from a Tiptap JSON doc").requiredOption("--title <title>", "Page title").option("--account <slug>", "Account slug").option("--wiki <slug>", "Wiki slug").option("--parent <ref>", "Parent page (UUID, pageHash, or slug)").option("--file <path>", "Read Tiptap JSON from this file").option("--content <json>", "Inline Tiptap JSON string").option("--stdin", "Read Tiptap JSON from stdin", false).action(async function(opts) {
+    try {
+      await runCreate(this, opts);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+};
+
+// src/commands/agent-help.ts
+import { readFile as readFile3 } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, join as join2 } from "path";
+var findAgentDoc = async () => {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    join2(here, "..", "AGENT.md"),
+    // dist/index.js → ../AGENT.md
+    join2(here, "..", "..", "AGENT.md")
+    // dev: src/commands → ../../AGENT.md
+  ];
+  for (const path of candidates) {
+    try {
+      return await readFile3(path, "utf8");
+    } catch {
+    }
+  }
+  throw new Error(
+    "AGENT.md not found. Reinstall the CLI or read https://github.com/slimwiki/slimwiki/blob/main/cli/AGENT.md."
+  );
+};
+var registerAgentHelpCommand = (program2) => {
+  program2.command("agent-help").description("Print the agent contract (AGENT.md) to stdout").action(async () => {
+    try {
+      const doc = await findAgentDoc();
+      process.stdout.write(doc);
+      if (!doc.endsWith("\n")) process.stdout.write("\n");
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+var program = new Command();
+program.name("slimwiki").description("Agent-friendly CLI for SlimWiki").version(VERSION).option("--human", "human-readable output (default: JSON)", false).option("--api-base <url>", "Override the SlimWiki API base URL");
+registerAuthCommands(program);
+registerAccountCommands(program);
+registerWikiCommands(program);
+registerPageCommands(program);
+registerAgentHelpCommand(program);
+program.parseAsync(process.argv).catch((err) => {
+  writeError(err);
+  process.exit(1);
+});