@calo-design/cli 0.6.0 → 0.7.0

package/bin/cli.js

@@ -20,6 +20,7 @@ const { cmdArtPush } = require("./art-push");
 const { cmdShare } = require("./share");
 const { cmdImage } = require("./imagegen");
 const { cmdLogin, cmdLogout, ensureLoggedIn, githubToken, reportEvent, ensureSession, loadSession, BROKER } = require("./login");
+const { cmdFeedback, cmdTasks } = require("./feedback");
 
 const ORG = "Calo-Design";
 const SKILL_REPO = `${ORG}/calo-design`;
@@ -779,6 +780,10 @@ function help() {
   ${c.dim("    share --slug x --dir dist --build --project calo-prototypes  --dry-run")}
   ${c.dim("gallery")}                                   serve the @calo/design-system component gallery locally (live from the runtime)
   ${c.dim("    gallery --port 8091")}
+  ${c.dim("feedback [slug]")}                           feedback inbox for shared prototypes (open threads; --all, --json)
+  ${c.dim("    feedback new <slug> <text>   comment|resolve|reopen <threadId>   shot <slug> <png>")}
+  ${c.dim("tasks [slug]")}                              triaged work items (--status todo|in_progress|done|wontfix, --json)
+  ${c.dim("    tasks new <slug> <title> --from <threadId>   start|done|wontfix <id>   done <id> --version v9")}
 
   Login is required once before init; the session refreshes automatically.
   init always installs the skill and ensures the shared ds/flows runtime on your machine;
@@ -803,6 +808,8 @@ function help() {
     else if (cmd === "insights") await cmdInsights();
     else if (cmd === "whoami") await cmdWhoami();
     else if (cmd === "gallery") await cmdGallery();
+    else if (cmd === "feedback") await cmdFeedback(args.slice(1));
+    else if (cmd === "tasks") await cmdTasks(args.slice(1));
     else help();
   } catch (err) {
     // Diagnostics go to stderr so stdout stays pure for machine callers (The Pass parses

package/bin/feedback.js

@@ -0,0 +1,193 @@
+"use strict";
+
+/**
+ * `calo-design feedback …` / `calo-design tasks …` — prototype feedback threads and
+ * triaged tasks, stored broker-side (calo-broker docs/feedback-plan.md).
+ *
+ * Triple duty: humans in the terminal, Claude working the task queue, and Design
+ * Kitchen shelling out with --json (same bridge pattern as `feed --json`). All calls
+ * ride the existing broker session (ensureSession → Bearer).
+ *
+ *   feedback [slug]                 inbox (open threads; --all for resolved too)
+ *   feedback new <slug> <text…>     plain thread (no pin)
+ *   feedback comment <threadId> <text…>
+ *   feedback resolve <threadId> | reopen <threadId>
+ *   feedback shot <slug> <file.png> upload a pin screenshot → prints URL
+ *   tasks [slug]                    list (--status todo|in_progress|done|wontfix)
+ *   tasks new <slug> <title…>       (--from <threadId> converts a thread, --body <text>)
+ *   tasks start|done|wontfix <id>   (done: --version <v> stamps closed_in_version)
+ */
+
+const fs = require("node:fs");
+const { ensureSession, BROKER } = require("./login");
+
+const c = { dim: (s) => `\x1b[2m${s}\x1b[0m`, b: (s) => `\x1b[1m${s}\x1b[0m`, g: (s) => `\x1b[32m${s}\x1b[0m`, y: (s) => `\x1b[33m${s}\x1b[0m` };
+const log = (s = "") => console.log(s);
+
+// Bounded fetch that speaks the broker's JSON envelope. GET+POST (login.js api() is
+// POST-only); --json callers get the raw response text so the bridge never re-encodes.
+async function call(method, pathname, { body, raw } = {}) {
+  const session = await ensureSession();
+  let res;
+  try {
+    res = await fetch(BROKER + pathname, {
+      method,
+      headers: {
+        authorization: `Bearer ${session}`,
+        ...(body !== undefined && !Buffer.isBuffer(body) ? { "content-type": "application/json" } : {}),
+        ...(Buffer.isBuffer(body) ? { "content-type": "image/png" } : {}),
+      },
+      body: body === undefined ? undefined : Buffer.isBuffer(body) ? body : JSON.stringify(body),
+      signal: AbortSignal.timeout(30000),
+    });
+  } catch (e) {
+    throw new Error(`can't reach the Calo broker at ${BROKER} (${e.message})`);
+  }
+  const text = await res.text();
+  let json;
+  try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
+  if (!res.ok) throw new Error(json.error || `${pathname} → HTTP ${res.status}`);
+  return raw ? text : json;
+}
+
+const flagVal = (args, name) => {
+  const i = args.indexOf(`--${name}`);
+  return i >= 0 && args[i + 1] && !args[i + 1].startsWith("--") ? args[i + 1] : undefined;
+};
+const stripFlags = (args) => args.filter((a, i, all) => !a.startsWith("--") && !(all[i - 1] || "").match(/^--(status|version|from|body|route|anchor|shot)$/));
+
+const ago = (ts) => {
+  const s = Math.max(1, Math.floor(Date.now() / 1000) - ts);
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`;
+  return `${Math.floor(s / 86400)}d`;
+};
+const short = (id) => id.slice(0, 8);
+// A thread's version is the deploy it was left on; slugs.last_version is current.
+const stale = (t) => t.version && t.current_version && t.version !== t.current_version;
+
+function printThread(t, { comments = false } = {}) {
+  const state = t.status === "resolved" ? c.g("✓ resolved") : c.y("● open");
+  const pin = t.anchor_json ? " 📌" : "";
+  const staleTag = stale(t) ? c.y(" [stale]") : "";
+  const task = t.task ? c.dim(`  → task ${short(t.task.id)} (${t.task.status})`) : "";
+  log(`${state}  ${c.b(t.slug)}${t.route ? c.dim(" " + t.route) : ""}${pin}${staleTag}  ${c.dim(short(t.id))}  ${c.dim(ago(t.created_at) + " ago")}${task}`);
+  const list = comments ? t.comments : t.comments.slice(0, 1);
+  for (const cm of list) {
+    const who = cm.kind === "system" ? c.dim("system") : cm.author.split("@")[0];
+    log(`    ${who}: ${cm.kind === "system" ? c.dim(cm.body) : cm.body}`);
+  }
+  if (!comments && t.comments.length > 1) log(c.dim(`    … ${t.comments.length - 1} more — calo-design feedback ${t.slug}`));
+}
+
+async function cmdFeedback(args = []) {
+  const json = args.includes("--json");
+  const sub = args[0] && !args[0].startsWith("--") ? args[0] : "";
+
+  if (sub === "new") {
+    const [slug, ...words] = stripFlags(args.slice(1));
+    const body = words.join(" ").trim();
+    if (!slug || !body) throw new Error("usage: calo-design feedback new <slug> <text…> [--shot <png>] [--anchor <json>] [--route <path>] [--version <v>]");
+    // Pin threads (Kitchen Review view): upload the frozen frame first, then attach
+    // its URL — /v1/feedback/thread only accepts screenshot URLs minted by /shot.
+    let screenshotUrl;
+    const shotFile = flagVal(args, "shot");
+    if (shotFile) {
+      const png = fs.readFileSync(shotFile);
+      const up = await call("POST", `/v1/feedback/shot?slug=${encodeURIComponent(slug)}`, { body: png });
+      screenshotUrl = up.url;
+    }
+    let anchor;
+    const anchorRaw = flagVal(args, "anchor");
+    if (anchorRaw) {
+      try { anchor = JSON.parse(anchorRaw); } catch { throw new Error("--anchor must be a JSON object"); }
+    }
+    const r = await call("POST", "/v1/feedback/thread", {
+      body: { slug, body, screenshotUrl, anchor, route: flagVal(args, "route"), version: flagVal(args, "version") },
+      raw: json,
+    });
+    if (json) return process.stdout.write(r + "\n");
+    log(`${c.g("✓")} thread ${short(r.thread.id)} opened on ${c.b(slug)}${screenshotUrl ? c.dim(" (with screenshot)") : ""}`);
+    return;
+  }
+
+  if (sub === "comment" || sub === "resolve" || sub === "reopen") {
+    const [threadId, ...words] = stripFlags(args.slice(1));
+    if (!threadId) throw new Error(`usage: calo-design feedback ${sub} <threadId>${sub === "comment" ? " <text…>" : ""}`);
+    const path = { comment: "/v1/feedback/comment", resolve: "/v1/feedback/resolve", reopen: "/v1/feedback/reopen" }[sub];
+    const body = sub === "comment" ? { threadId, body: words.join(" ").trim() } : { threadId };
+    if (sub === "comment" && !body.body) throw new Error("comment text required");
+    const r = await call("POST", path, { body, raw: json });
+    if (json) return process.stdout.write(r + "\n");
+    log(`${c.g("✓")} ${sub === "comment" ? "commented" : sub + "ed"}`);
+    return;
+  }
+
+  if (sub === "shot") {
+    const [slug, file] = stripFlags(args.slice(1));
+    if (!slug || !file) throw new Error("usage: calo-design feedback shot <slug> <file.png>");
+    const png = fs.readFileSync(file);
+    const r = await call("POST", `/v1/feedback/shot?slug=${encodeURIComponent(slug)}`, { body: png, raw: json });
+    if (json) return process.stdout.write(r + "\n");
+    log(`${c.g("✓")} ${r.url}`);
+    return;
+  }
+
+  // list: `feedback` (inbox: open everywhere) or `feedback <slug>` (--all incl. resolved)
+  const slug = sub || undefined;
+  const all = args.includes("--all");
+  const qs = new URLSearchParams();
+  if (slug) qs.set("slug", slug);
+  if (!all) qs.set("status", "open");
+  const r = await call("GET", `/v1/feedback?${qs}`, { raw: json });
+  if (json) return process.stdout.write(r + "\n");
+  const threads = r.threads;
+  if (!threads.length) return log(c.dim(slug ? `no ${all ? "" : "open "}feedback on ${slug}` : "inbox zero 🎉"));
+  log(c.b(`\n${threads.length} thread(s)${slug ? ` on ${slug}` : ""}${all ? "" : " (open)"}\n`));
+  for (const t of threads) printThread(t, { comments: !!slug });
+}
+
+async function cmdTasks(args = []) {
+  const json = args.includes("--json");
+  const sub = args[0] && !args[0].startsWith("--") ? args[0] : "";
+
+  if (sub === "new") {
+    const [slug, ...words] = stripFlags(args.slice(1));
+    const title = words.join(" ").trim();
+    if (!slug || !title) throw new Error("usage: calo-design tasks new <slug> <title…> [--from <threadId>] [--body <text>]");
+    const body = { slug, title, sourceThread: flagVal(args, "from"), body: flagVal(args, "body") };
+    const r = await call("POST", "/v1/tasks", { body, raw: json });
+    if (json) return process.stdout.write(r + "\n");
+    log(`${c.g("✓")} task ${short(r.task.id)}: ${r.task.title}${r.task.source_thread ? c.dim(` (from thread ${short(r.task.source_thread)})`) : ""}`);
+    return;
+  }
+
+  if (["start", "done", "wontfix"].includes(sub)) {
+    const [id] = stripFlags(args.slice(1));
+    if (!id) throw new Error(`usage: calo-design tasks ${sub} <id>`);
+    const status = sub === "start" ? "in_progress" : sub;
+    const body = { id, status, ...(sub === "done" && flagVal(args, "version") ? { closedInVersion: flagVal(args, "version") } : {}) };
+    const r = await call("POST", "/v1/tasks/update", { body, raw: json });
+    if (json) return process.stdout.write(r + "\n");
+    log(`${c.g("✓")} ${r.task.title} → ${c.b(r.task.status)}${r.task.closed_in_version ? c.dim(` (${r.task.closed_in_version})`) : ""}`);
+    if (sub === "done") log(c.dim("  source thread (if any) auto-resolved"));
+    return;
+  }
+
+  const slug = sub || undefined;
+  const qs = new URLSearchParams();
+  if (slug) qs.set("slug", slug);
+  const status = flagVal(args, "status");
+  if (status) qs.set("status", status);
+  const r = await call("GET", `/v1/tasks?${qs}`, { raw: json });
+  if (json) return process.stdout.write(r + "\n");
+  const list = r.tasks;
+  if (!list.length) return log(c.dim("no tasks" + (slug ? ` on ${slug}` : "")));
+  log(c.b(`\n${list.length} task(s)${slug ? ` on ${slug}` : ""}\n`));
+  const badge = { todo: c.y("○ todo"), in_progress: c.b("◐ in progress"), done: c.g("● done"), wontfix: c.dim("✕ wontfix") };
+  for (const t of list) {
+    log(`${badge[t.status] || t.status}  ${c.b(t.slug)}  ${t.title}  ${c.dim(short(t.id))}${t.source_thread ? c.dim(" ← " + short(t.source_thread)) : ""}${t.closed_in_version ? c.dim(" " + t.closed_in_version) : ""}`);
+  }
+}
+
+module.exports = { cmdFeedback, cmdTasks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calo-design/cli",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "One-line setup for Calo design tooling: logs in with your Calo email and installs the calo-design skill + design-system packages. No GitHub account needed.",
   "bin": {
     "calo-design": "bin/cli.js"