@tenyokjs/devdevian-cli 0.0.0-stage → 0.2.0-alpha.1

package/lib/client.mjs

@@ -0,0 +1,143 @@
+import {
+  readFile,
+  writeFile,
+  mkdir,
+  chmod,
+  rename,
+  unlink,
+  lstat,
+} from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+export function originOf(value) {
+  const url = new URL(value);
+  if (
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash ||
+    url.pathname !== "/" ||
+    !(
+      url.protocol === "https:" ||
+      (url.protocol === "http:" &&
+        ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))
+    )
+  )
+    throw Error(
+      "Use an HTTPS server origin, or HTTP on loopback for local development.",
+    );
+  return url.origin;
+}
+export const clean = (value) =>
+  String(value ?? "")
+    .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, "");
+export function configFile(env = process.env) {
+  return join(
+    env.DEVDEVIAN_CONFIG_DIR || join(homedir(), ".config", "devdevian"),
+    "credentials.json",
+  );
+}
+export async function loadConfig() {
+  try {
+    const path = configFile(),
+      info = await lstat(path);
+    if (!info.isFile() || info.isSymbolicLink())
+      throw Error("The credentials path must be a regular file.");
+    if (process.platform !== "win32" && info.mode & 0o077)
+      throw Error(
+        "Credentials permissions are too broad. Run chmod 600 on " + path,
+      );
+    const config = JSON.parse(await readFile(path, "utf8"));
+    config.origin = originOf(config.origin);
+    if (!/^ddv_[A-Za-z0-9_-]{43}$/.test(config.token || ""))
+      throw Error("Invalid saved CLI credentials. Sign in again.");
+    return config;
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw e;
+  }
+}
+export async function saveConfig(config) {
+  const file = configFile(),
+    dir = join(file, "..");
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  const info = await lstat(dir);
+  if (info.isSymbolicLink() || !info.isDirectory())
+    throw Error("The credentials directory must be a real directory.");
+  const temp = join(dir, ".credentials-" + randomBytes(8).toString("hex"));
+  try {
+    await writeFile(temp, JSON.stringify(config) + "\n", {
+      mode: 0o600,
+      flag: "wx",
+    });
+    await chmod(temp, 0o600);
+    await rename(temp, file);
+  } finally {
+    await unlink(temp).catch((e) => {
+      if (e.code !== "ENOENT") throw e;
+    });
+  }
+}
+export async function removeConfig() {
+  try {
+    await unlink(configFile());
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+}
+export function client(origin, token = null) {
+  origin = originOf(origin);
+  return async (path, { method = "GET", body, signal } = {}) => {
+    if (!path.startsWith("/") || path.startsWith("//"))
+      throw Error("Invalid API path.");
+    let response;
+    try {
+      response = await fetch(origin + "/api" + path, {
+        method,
+        redirect: "error",
+        headers: {
+          Accept: "application/json",
+          ...(body ? { "Content-Type": "application/json" } : {}),
+          ...(token ? { Authorization: "Bearer " + token } : {}),
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal: signal
+          ? AbortSignal.any([signal, AbortSignal.timeout(20000)])
+          : AbortSignal.timeout(20000),
+      });
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      throw Error(
+        "Could not reach Devdevian. Check your connection and server address.",
+      );
+    }
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of response.body) {
+      size += chunk.length;
+      if (size > 2 * 1024 * 1024)
+        throw Error("Devdevian response is too large. Use a smaller page.");
+      chunks.push(chunk);
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw Error(
+        `Devdevian returned an unexpected response (HTTP ${response.status}). Try again later.`,
+      );
+    }
+    if (!response.ok) {
+      const error = Error(
+        clean(data.error || `Request failed (HTTP ${response.status}).`),
+      );
+      error.status = response.status;
+      throw error;
+    }
+    return data;
+  };
+}

package/lib/tui-data.mjs

@@ -0,0 +1,199 @@
+export const navigation = [
+  ["inbox", "Inbox", "Replies & mentions"],
+  ["feed", "Public feed", "Developer commons"],
+  ["open", "Open conversation", "Jump to a post"],
+  ["ask", "Ask a question", "Find a way forward"],
+  ["review", "Request code review", "Another pair of eyes"],
+  ["communities", "Communities", "Your private spaces"],
+  ["search", "Search", "Find a conversation"],
+  ["devices", "Connected terminals", "Manage CLI access"],
+  ["help", "Help", "Keys & commands"],
+];
+export async function loadPage(api, route, signal) {
+  const get = (path) => api(path, { signal }),
+    page = route.page || 1;
+  if (route.view === "feed")
+    return {
+      ...(await get("/posts?limit=12&page=" + page)),
+      title: "Public feed",
+      subtitle: "Questions, ideas and code worth discussing.",
+    };
+  if (route.view === "inbox")
+    return {
+      ...(await get("/notifications?page=" + page)),
+      title: "Inbox",
+      subtitle: "Your replies, mentions and review updates.",
+    };
+  if (route.view === "communities")
+    return {
+      ...(await get("/communities?limit=12&page=" + page)),
+      title: "Communities",
+      subtitle: "Private spaces, shared context. Enter opens a community.",
+    };
+  if (route.view === "search")
+    return {
+      ...(await get(
+        "/search?type=" +
+          (route.type || "posts") +
+          "&q=" +
+          encodeURIComponent(route.query || "") +
+          "&page=" +
+          page,
+      )),
+      title: "Search",
+      subtitle: route.query
+        ? "Results for “" + route.query + "”"
+        : "Press / and type /search followed by your query.",
+    };
+  if (route.view === "devices")
+    return {
+      ...(await get("/cli/sessions")),
+      title: "Connected terminals",
+      subtitle: "Enter to revoke a terminal. Revoking this one signs it out.",
+    };
+  if (route.view === "community") {
+    const community = await get("/communities/" + encodeURIComponent(route.id));
+    const posts = community.is_member
+      ? await get(
+          "/posts?limit=12&community=" +
+            encodeURIComponent(route.id) +
+            "&page=" +
+            page,
+        )
+      : { items: [] };
+    return {
+      ...posts,
+      community,
+      title: community.name,
+      subtitle: community.is_member
+        ? "Members-only conversations. N creates a conversation here."
+        : community.requested
+          ? "Your access request is pending."
+          : "Private community. J requests access.",
+    };
+  }
+  if (route.view === "post") {
+    const post = await get("/posts/" + route.id + "?reply_page=" + page);
+    let items = post.replies,
+      pagination = post.reply_pagination;
+    if (route.tab === "feedback") {
+      const feedback = await get(
+        "/posts/" + route.id + "/code-reviews?page=" + page,
+      );
+      items = feedback.items;
+      pagination = feedback.pagination;
+    }
+    return {
+      post,
+      items,
+      pagination,
+      title: post.title,
+      subtitle:
+        (post.community_id ? "Private community" : "Public feed") +
+        " · " +
+        post.kind +
+        " · by " +
+        post.name,
+    };
+  }
+  if (route.view === "thread") {
+    const post = await get("/posts/" + route.postId),
+      replies = await get(
+        `/posts/${route.postId}/replies?parent_id=${route.parent.id}&page=${page}`,
+      );
+    return {
+      post,
+      ...replies,
+      title: "Reply thread",
+      subtitle: "Replying to " + route.parent.name,
+    };
+  }
+  if (route.view === "feedback") {
+    const [post, notes] = await Promise.all([
+      get("/posts/" + route.postId),
+      get(`/posts/${route.postId}/code-reviews?target_id=${route.id}`),
+    ]);
+    const note = notes.items.find((item) => item.id === Number(route.id));
+    if (!note) throw Error("This feedback is no longer available.");
+    const replies = await get(
+      `/posts/${route.postId}/code-reviews/${route.id}/replies?page=${page}${route.targetReply ? "&target_id=" + route.targetReply : ""}`,
+    );
+    return {
+      post,
+      note,
+      items: [
+        { ...note, entryType: "note" },
+        ...replies.items.map((item) => ({
+          ...item,
+          entryType: "feedbackReply",
+        })),
+      ],
+      pagination: replies.pagination,
+      title: "Code feedback",
+      subtitle: `Lines ${note.start_line}–${note.end_line} · ${note.resolved ? "resolved" : "open"}`,
+    };
+  }
+  return { items: [], title: "Your workspace", subtitle: "" };
+}
+export function contentLines(route, data) {
+  if (route.view === "help")
+    return [
+      "A developer workspace, in your terminal.",
+      "",
+      "Tab              Switch navigation / content / command bar",
+      "↑ ↓              Select a section, conversation or reply",
+      "Enter            Open the selected item",
+      "Esc              Back / leave an input",
+      "← →              Switch conversation tabs",
+      "Page Up / Down   Scroll a conversation or list",
+      "N / A            New conversation / ask a question",
+      "R                Reply in a conversation; refresh a list",
+      "C                Add feedback on code lines",
+      "S                Resolve / reopen selected code feedback",
+      "E / D            Edit / delete your own feedback or reply",
+      "O                Open this conversation in your browser",
+      "/                Focus the command / search bar",
+      "Ctrl+S           Preview the current form",
+      "Ctrl+C           Exit and restore the original terminal",
+      "",
+      "Commands: /feed  /inbox  /search words  /open 142",
+      "          /ask  /review  /communities  /devices  /logout  /quit",
+      "",
+      "Text fields: arrows move the caret; Home/End move within a line.",
+      "Multiline fields: Enter adds a line; Tab changes field.",
+      "Nothing is published until you confirm the preview.",
+      "A -> Z: your browser account and this terminal use the same data.",
+    ];
+  if (route.view === "community" && !data.community?.is_member)
+    return [
+      data.community?.description || "",
+      "",
+      data.community?.requested
+        ? "Access requested. The owner or validators will review it."
+        : "Press J to request access.",
+    ];
+  if (route.view === "post" && (!route.tab || route.tab === "overview")) {
+    const p = data.post;
+    if (!p) return [];
+    const lines = [p.body || ""];
+    if (p.review_focus) lines.push("", "REVIEW FOCUS", p.review_focus);
+    if (p.code)
+      lines.push(
+        "",
+        "CODE SNIPPET",
+        ...p.code
+          .split("\n")
+          .map((line, index) => String(index + 1).padStart(4) + "  " + line),
+      );
+    if (p.links?.length)
+      lines.push(
+        "",
+        "LINKS",
+        ...p.links.map((link) => link.label + " · " + link.url),
+      );
+    if (p.archived_at || p.locked_at)
+      lines.push("", "Replies are paused for this conversation.");
+    return lines;
+  }
+  return [];
+}

package/lib/tui-model.mjs

@@ -0,0 +1,167 @@
+import stringWidth from "string-width";
+import wrapAnsi from "wrap-ansi";
+import { clean } from "./client.mjs";
+const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export const graphemes = (value) =>
+  Array.from(segmenter.segment(value), (part) => part.segment);
+export function clip(value, width) {
+  const text = clean(value).replace(/\n/g, " ");
+  if (width <= 0) return "";
+  if (stringWidth(text) <= width) return text;
+  let result = "";
+  for (const part of graphemes(text)) {
+    if (stringWidth(result + part) > width - 1) break;
+    result += part;
+  }
+  return result + "…";
+}
+export function wrap(value, width) {
+  return wrapAnsi(clean(value).replace(/\t/g, "  "), Math.max(1, width), {
+    hard: true,
+    trim: false,
+  }).split("\n");
+}
+export function editText(
+  value,
+  cursor,
+  input,
+  key,
+  { multiline = false, max = 15000 } = {},
+) {
+  const chars = graphemes(value),
+    at = Math.max(0, Math.min(cursor, chars.length));
+  if (multiline && (key.upArrow || key.downArrow)) {
+    const start = chars.slice(0, at).lastIndexOf("\n") + 1,
+      column = at - start;
+    if (key.upArrow) {
+      if (!start) return { value, cursor: 0 };
+      const previous = chars.slice(0, start - 1).lastIndexOf("\n") + 1;
+      return { value, cursor: Math.min(start - 1, previous + column) };
+    }
+    const end = chars.indexOf("\n", at);
+    if (end < 0) return { value, cursor: chars.length };
+    const next = chars.indexOf("\n", end + 1);
+    return {
+      value,
+      cursor: Math.min(next < 0 ? chars.length : next, end + 1 + column),
+    };
+  }
+  if (key.leftArrow) return { value, cursor: Math.max(0, at - 1) };
+  if (key.rightArrow) return { value, cursor: Math.min(chars.length, at + 1) };
+  if (key.home || (key.ctrl && input === "a")) {
+    const previous = chars.slice(0, at).lastIndexOf("\n");
+    return { value, cursor: previous + 1 };
+  }
+  if (key.end || (key.ctrl && input === "e")) {
+    const next = chars.indexOf("\n", at);
+    return { value, cursor: next < 0 ? chars.length : next };
+  }
+  if (key.ctrl && input === "u") {
+    let start = chars.slice(0, at).lastIndexOf("\n") + 1;
+    return {
+      value: [...chars.slice(0, start), ...chars.slice(at)].join(""),
+      cursor: start,
+    };
+  }
+  if (key.ctrl && input === "k") {
+    const end = chars.indexOf("\n", at);
+    return {
+      value: [...chars.slice(0, at), ...(end < 0 ? [] : chars.slice(end))].join(
+        "",
+      ),
+      cursor: at,
+    };
+  }
+  if (key.backspace) {
+    if (!at) return { value, cursor: at };
+    return {
+      value: [...chars.slice(0, at - 1), ...chars.slice(at)].join(""),
+      cursor: at - 1,
+    };
+  }
+  if (key.delete)
+    return {
+      value: [...chars.slice(0, at), ...chars.slice(at + 1)].join(""),
+      cursor: at,
+    };
+  if (key.ctrl || key.meta || key.escape || key.tab)
+    return { value, cursor: at };
+  let insertion = key.return
+    ? multiline
+      ? "\n"
+      : ""
+    : clean(input).replace(/\r/g, "");
+  if (!multiline) insertion = insertion.replace(/\n/g, " ");
+  if (!insertion) return { value, cursor: at };
+  const remaining = Math.max(0, max - value.length),
+    parts = [];
+  let length = 0;
+  for (const part of graphemes(insertion)) {
+    if (length + part.length > remaining) break;
+    parts.push(part);
+    length += part.length;
+  }
+  return {
+    value: [...chars.slice(0, at), ...parts, ...chars.slice(at)].join(""),
+    cursor: at + parts.length,
+  };
+}
+export function cursorLines(value, cursor, width) {
+  const parts = graphemes(value),
+    lines = wrap(
+      parts.slice(0, cursor).join("") + "▏" + parts.slice(cursor).join(""),
+      width,
+    );
+  const marker = lines.findIndex((line) => line.includes("▏"));
+  return { lines, line: Math.max(0, marker) };
+}
+export function parseCommand(text) {
+  const [cmd, ...rest] = text.trim().replace(/^\//, "").split(/\s+/);
+  const arg = rest.join(" ");
+  if (
+    [
+      "feed",
+      "inbox",
+      "communities",
+      "search",
+      "ask",
+      "review",
+      "help",
+      "devices",
+    ].includes(cmd)
+  )
+    return { command: cmd, arg };
+  if (
+    cmd === "open" &&
+    /^[1-9]\d*$/.test(arg) &&
+    Number.isSafeInteger(Number(arg))
+  )
+    return { command: cmd, arg: Number(arg) };
+  if (["quit", "logout"].includes(cmd)) return { command: cmd };
+  throw Error(
+    "Use /feed, /inbox, /search words, /open ID, /ask, /review, /communities, /devices, /help or /quit.",
+  );
+}
+export class PageCache {
+  constructor({ max = 40, ttl = 30000 } = {}) {
+    this.rows = new Map();
+    this.max = max;
+    this.ttl = ttl;
+  }
+  get(key) {
+    const row = this.rows.get(key);
+    if (!row || Date.now() - row.time > this.ttl) return null;
+    this.rows.delete(key);
+    this.rows.set(key, row);
+    return row.value;
+  }
+  set(key, value) {
+    this.rows.delete(key);
+    this.rows.set(key, { value, time: Date.now() });
+    while (this.rows.size > this.max)
+      this.rows.delete(this.rows.keys().next().value);
+  }
+  clear() {
+    this.rows.clear();
+  }
+}