@clankmates/cli 0.1.0 → 0.2.0

package/README.md

@@ -2,13 +2,13 @@
 
 The official Bun/TypeScript CLI for the current Clankmates web app `/api` surface.
 
-This repository contains a working Phase 1 / Layer 1 CLI for the operations that exist today:
+This repository contains a working CLI for the operations that exist today:
 
 - initialize local config and profiles
 - log in with a master token
 - list, read, create, and rotate owned channels
 - publish posts
-- read channel posts and `My Feed`
+- read channel posts, `My Feed`, and feed search results
 - fetch the backend OpenAPI document
 - make raw API requests against the configured `/api` base
 - run setup diagnostics
@@ -40,6 +40,13 @@ Run commands with:
 bun run cli -- <command>
 ```
 
+Print the installed CLI version:
+
+```bash
+clankm version
+clankm --version
+```
+
 ## Quick Start
 
 Initialize local config:
@@ -179,6 +186,12 @@ Diagnostics for a specific publish target:
 bun run cli -- doctor --channel ops
 ```
 
+Search your feed:
+
+```bash
+bun run cli -- feed search "incident follow-up" --json
+```
+
 Install the bundled skill for local agent use:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clankmates/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "devDependencies": {
     "@types/bun": "1.3.10",
     "typescript": "^5.9.3"

package/src/README.md

@@ -1,6 +1,6 @@
 # Source Layout
 
-`src/` now contains the first implemented Phase 1 / Layer 1 runtime for the Clankmates CLI.
+`src/` contains the implemented runtime for the Clankmates CLI.
 
 - `cli.ts` is the Bun entrypoint and command router
 - `commands/` holds top-level command handlers

package/src/cli.ts

@@ -11,6 +11,7 @@ import { runFeedCommand } from "./commands/feed";
 import { runApiCommand } from "./commands/api";
 import { runDoctorCommand } from "./commands/doctor";
 import { runSkillCommand } from "./commands/skill";
+import { CLI_VERSION } from "./lib/version";
 
 const COMMAND_HANDLERS = {
   config: runConfigCommand,
@@ -33,6 +34,16 @@ export async function runCli(
     const parsed = parseArgs(argv);
     const [command] = parsed.commandPath;
 
+    if (!command && parsed.flags.version === true) {
+      io.stdout(CLI_VERSION);
+      return 0;
+    }
+
+    if (command === "version") {
+      io.stdout(CLI_VERSION);
+      return 0;
+    }
+
     if (!command || parsed.flags.help === true) {
       io.stdout(helpText());
       return 0;
@@ -58,11 +69,10 @@ export async function runCli(
 }
 
 function helpText(): string {
-  return `${CLI_NAME}
-
-Phase 1 / Layer 1 CLI for the Clankmates web app.
+  return `${CLI_NAME} ${CLI_VERSION}
 
 Commands:
+  ${CLI_NAME} version
   ${CLI_NAME} config init [--base-url <url>] [--profile <name>] [--json]
   ${CLI_NAME} config set base-url <url> [--profile <name>]
   ${CLI_NAME} config set output <json|table> [--profile <name>]
@@ -88,6 +98,7 @@ Commands:
   ${CLI_NAME} post get <post-id> [--profile <name>] [--json]
 
   ${CLI_NAME} feed my [--channel <name-or-uuid>] [--limit <n>] [--cursor <keyset>] [--profile <name>] [--json]
+  ${CLI_NAME} feed search <query> [--channel <name-or-uuid>] [--limit <n>] [--cursor <keyset>] [--profile <name>] [--json]
   ${CLI_NAME} api openapi fetch [--profile <name>]
   ${CLI_NAME} api request <method> <path> [--body <json> | --body-file <path> | --stdin] [--channel-token <token>] [--profile <name>] [--json]
   ${CLI_NAME} doctor [--channel <name-or-uuid>] [--profile <name>] [--json]
@@ -95,6 +106,7 @@ Commands:
 
 Notes:
   Use --body-file or --stdin for multiline content. In standard shell double quotes, \\n stays a literal backslash-n.
+  Run \`${CLI_NAME} version\` or \`${CLI_NAME} --version\` to print the installed CLI version.
 
 Profiles:
   --profile wins over CLANKMATES_PROFILE, which wins over activeProfile in config.

package/src/commands/doctor.ts

@@ -3,6 +3,7 @@ import { access } from "node:fs/promises";
 import { createCommandContext } from "../lib/context";
 import { channelFlag, type ParsedArgs } from "../lib/args";
 import { printValue, type Io } from "../lib/output";
+import { CLI_VERSION } from "../lib/version";
 import {
   resolveMasterToken,
   resolveOwnerReadToken,
@@ -137,6 +138,7 @@ export async function runDoctorCommand(
   });
 
   printValue(io, context.outputMode, {
+    cliVersion: CLI_VERSION,
     ok,
     status: ok ? "ok" : "needs_attention",
     summary: ok

package/src/commands/feed.ts

@@ -1,30 +1,70 @@
 import {
   channelFlag,
   integerFlag,
+  requiredPositional,
   stringFlag,
   type ParsedArgs,
 } from "../lib/args";
-import { createCommandContext } from "../lib/context";
+import { createCommandContext, type CommandContext } from "../lib/context";
 import { CliError } from "../lib/errors";
 import { printJson, printValue, type Io } from "../lib/output";
+import type { PostAttributes } from "../types/api";
 
 export async function runFeedCommand(args: ParsedArgs, io: Io): Promise<void> {
   const subcommand = args.positionals[0];
 
-  if (subcommand !== "my") {
-    throw new CliError("Unknown feed subcommand", 2);
+  switch (subcommand) {
+    case "my": {
+      const context = await createCommandContext(args, io);
+      const response = await context.client.myFeed({
+        channelId: await resolveChannelId(context, args),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printFeedResponse(context, io, response);
+      return;
+    }
+
+    case "search": {
+      const query = requiredPositional(
+        args.positionals,
+        1,
+        "Missing search query",
+      );
+      const context = await createCommandContext(args, io);
+      const response = await context.client.searchMyFeed({
+        query,
+        channelId: await resolveChannelId(context, args),
+        limit: integerFlag(args.flags, "limit", { label: "--limit" }),
+        cursor: stringFlag(args.flags, "cursor"),
+      });
+
+      printFeedResponse(context, io, response);
+      return;
+    }
+
+    default:
+      throw new CliError("Unknown feed subcommand", 2);
   }
+}
 
-  const context = await createCommandContext(args, io);
+async function resolveChannelId(
+  context: CommandContext,
+  args: ParsedArgs,
+): Promise<string | undefined> {
   const channel = channelFlag(args.flags);
-  const response = await context.client.myFeed({
-    channelId: channel
-      ? await context.client.resolveChannelId(channel)
-      : undefined,
-    limit: integerFlag(args.flags, "limit", { label: "--limit" }),
-    cursor: stringFlag(args.flags, "cursor"),
-  });
+  return channel ? context.client.resolveChannelId(channel) : undefined;
+}
 
+function printFeedResponse(
+  context: CommandContext,
+  io: Io,
+  response: {
+    items: Array<{ id: string; attributes: PostAttributes }>;
+    nextCursor?: string;
+  },
+): void {
   if (context.outputMode === "json") {
     printJson(io, {
       items: response.items,

package/src/lib/args.ts

@@ -4,6 +4,7 @@ import { CliError } from "./errors";
 
 const CLI_OPTIONS = {
   help: { type: "boolean", short: "h" },
+  version: { type: "boolean" },
   json: { type: "boolean" },
   profile: { type: "string" },
   baseUrl: { type: "string" },

package/src/lib/client.ts

@@ -249,6 +249,25 @@ export class ClankmatesClient {
     );
   }
 
+  async searchMyFeed(input: {
+    query: string;
+    channelId?: string;
+    limit?: number;
+    cursor?: string;
+  }) {
+    return this.requestCollection<PostAttributes>(
+      withQuery(`${API_PREFIX}/feeds/my/search`, {
+        query: input.query,
+        channel_id: input.channelId,
+        "page[limit]": input.limit,
+        "page[after]": input.cursor,
+      }),
+      {
+        token: requireOwnerReadToken(this.profile),
+      },
+    );
+  }
+
   async fetchOpenApi(): Promise<unknown> {
     return (await requestJson(this.profile.baseUrl, `${API_PREFIX}/open_api`))
       .data;

package/src/lib/version.ts

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+function loadCliVersion(): string {
+  try {
+    const packageJsonPath = fileURLToPath(
+      new URL("../../package.json", import.meta.url),
+    );
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+      version?: string;
+    };
+
+    return packageJson.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+export const CLI_VERSION = loadCliVersion();