plotcoder-board 0.1.0

package/src/board/workflows.d.ts

@@ -0,0 +1,24 @@
+// Type surface for workflows.js — workflows (R27) and the brief (R28).
+
+import type { BoardState } from "./reducer";
+
+export type Workflow = {
+  id: string;
+  name: string;
+  /** What the writer says to their agent, verbatim or nearly. */
+  ask: string;
+  /** The tools the agent will compose. */
+  tools: string[];
+  /** The rule the agent keeps while doing it. */
+  then: string;
+};
+
+export declare const WORKFLOWS: readonly Workflow[];
+export declare function workflowById(id: string): Workflow | null;
+
+/** The brief for one card, or several in order. Null when none of the ids is a card. */
+export declare function segmentBrief(
+  state: BoardState,
+  ids: string[],
+  options?: { title?: string },
+): string | null;

package/src/board/workflows.js

@@ -0,0 +1,116 @@
+// Workflows (R27, closing open question 24) and the first step toward the
+// horizon (R28): the brief.
+//
+// A workflow is a named sequence of tool calls a writer launches as one act.
+// The decision recorded here: a workflow is a **prompt in the repo** — the
+// agent interprets it with the tools it already has — and where the sequence
+// is fixed and needs no judgement it is a tool instead (read_wall, organize,
+// apply_template, export_fountain already are). Nothing is stored in the
+// project; a writer says the workflow's name to their agent, and the app
+// shows the list so they know what they can ask for. DOM-free, shared by the
+// app, the skill and the MCP server.
+
+export const WORKFLOWS = [
+  {
+    id: "break-a-treatment",
+    name: "Break a treatment into a wall",
+    ask: "Here is a treatment. Break it into a wall: one card per scene with a headline and what changes, the cast on each card, the places, and the major turns marked as beats.",
+    tools: ["list_words", "read_wall", "list_reminders", "new_board", "rename_project", "set_target", "create_note", "list_board", "add_character", "cast", "update_character", "set_location", "set_rank", "set_length", "set_plant", "create_arrow", "create_group", "organize"],
+    then: "Read the wall (read_wall) and say what it asks. A treatment is cards, one create_note each, with characters, location, rank and plants on the call; import_fountain is the door for pages, not a treatment — a scene's text measures its card.",
+  },
+  {
+    id: "read-and-raise",
+    name: "Read the wall and raise questions",
+    ask: "Read the wall and tell me what it asks: the sagging run, the missing setup, the person who disappears, the two scenes doing one job. Change nothing.",
+    tools: ["read_wall", "list_board", "list_reminders"],
+    then: "Wait for the writer; propose, do not fix.",
+  },
+  {
+    id: "lay-a-structure",
+    name: "Lay a structure over what is here",
+    ask: "Lay the turns structure on this wall, then move my scenes under the beats they belong to and organize the rows.",
+    tools: ["apply_template", "list_board", "move_note", "organize"],
+    then: "Say which scenes you could not place.",
+  },
+  {
+    id: "draft-a-sequence",
+    name: "Draft a sequence in Fountain from its cards",
+    ask: "Draft the scenes between the second and third beats as Fountain, from their cards, cast pages and places, and write each one onto its card.",
+    tools: ["read_pages", "list_board", "write_scene", "export_fountain"],
+    then: "Keep to the change line of each card; do not add scenes.",
+  },
+  {
+    id: "restick",
+    name: "Restick the remaining cards after the pages moved",
+    ask: "The pages changed the story. Read the pages, tell me which cards no longer say what their scenes do, and rewrite those headlines and change lines to match.",
+    tools: ["read_pages", "update_note", "read_wall"],
+    then: "Never touch a card whose scene is unwritten.",
+  },
+  {
+    id: "brief-a-segment",
+    name: "Brief a segment for video",
+    ask: "Brief the scene on this card for a video tool: who is in it and what they look and sound like, where it is, what happens, and what must be true after it.",
+    tools: ["segment_brief", "build_segment", "add_take", "list_takes", "read_pages", "list_board"],
+    then: "Hand the brief to the writer to approve before any tool makes anything; file what is made with add_take.",
+  },
+];
+
+export function workflowById(id) {
+  return WORKFLOWS.find((workflow) => workflow.id === id) ?? null;
+}
+
+// --- The brief (R28, first step; closing open question 25 for now) ----------
+//
+// A segment is a card — one scene — by default, and the run between two
+// beats when the writer asks for a sequence. The brief is text: everything
+// the wall knows about the segment, in the order a video tool would need it.
+// No provider is named (question 26): the brief is what any of them is
+// handed.
+
+function personLine(character) {
+  const lines = [];
+  if (character.looks) lines.push(`looks: ${character.looks}`);
+  if (character.voice) lines.push(`voice: ${character.voice}`);
+  if (character.wants) lines.push(`wants: ${character.wants}`);
+  if (character.needs) lines.push(`needs: ${character.needs}`);
+  return `${character.name}${lines.length ? ` — ${lines.join("; ")}` : " — (no page yet)"}`;
+}
+
+/**
+ * The brief for one card, or for several in order (a run between beats).
+ * Returns plain text with headed lines, and nothing the wall does not hold.
+ */
+export function segmentBrief(state, ids, options = {}) {
+  const byId = new Map(state.notes.map((note) => [note.id, note]));
+  const notes = ids.map((id) => byId.get(id)).filter(Boolean);
+  if (notes.length === 0) return null;
+  const people = new Map();
+  for (const note of notes) {
+    for (const id of note.characterIds ?? []) {
+      const character = state.characters.find((item) => item.id === id);
+      if (character) people.set(id, character);
+    }
+  }
+  const places = [...new Set(notes.map((note) => note.location).filter(Boolean))];
+  const lines = [];
+  lines.push(`SEGMENT: ${notes.length === 1 ? notes[0].headline : `${notes.length} scenes, from "${notes[0].headline}" to "${notes.at(-1).headline}"`}`);
+  if (options.title) lines.push(`FROM: ${options.title}`);
+  if (state.logline) lines.push(`STORY: ${state.logline}`);
+  lines.push(`PEOPLE: ${people.size ? [...people.values()].map(personLine).join(" | ") : "(nobody cast)"}`);
+  lines.push(`PLACES: ${places.length ? places.join("; ") : "(none set)"}`);
+  for (const note of notes) {
+    lines.push("");
+    lines.push(`SCENE: ${note.headline}${note.location ? ` — at ${note.location}` : ""}`);
+    lines.push(`WHAT CHANGES: ${note.change}`);
+    if (note.plants) lines.push("PLANTS: something here pays off later; keep it visible.");
+    if (note.text && note.text.trim()) {
+      lines.push("SCRIPT:");
+      lines.push(note.text.trim());
+    } else {
+      lines.push("SCRIPT: (unwritten — build from the change line)");
+    }
+  }
+  lines.push("");
+  lines.push(`AFTER: ${notes.at(-1).change}`);
+  return lines.join("\n");
+}

package/src/board/zip.d.ts

@@ -0,0 +1,5 @@
+// Type surface for zip.js — a stored zip writer (Roadmap 2, item 5).
+
+export declare function crc32(bytes: Uint8Array): number;
+export declare function zip(entries: Array<{ name: string; bytes: Uint8Array | ArrayBuffer; date?: Date | string }>, now?: Date): Uint8Array;
+export declare function unzip(bytes: Uint8Array): Array<{ name: string; bytes: Uint8Array }>;

package/src/board/zip.js

@@ -0,0 +1,134 @@
+// A zip writer (Roadmap 2, item 5): every file of a person or a project as
+// one package. Stored, not deflated — pictures and video are already
+// compressed — with a CRC-32 per entry as the format requires. Pure and
+// DOM-free: bytes in, bytes out, so it is tested like the kernel and works
+// in Node as in the browser.
+
+const CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+
+export function crc32(bytes) {
+  let crc = 0xffffffff;
+  for (let i = 0; i < bytes.length; i += 1) crc = CRC_TABLE[(crc ^ bytes[i]) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function dosDateTime(date) {
+  const d = date instanceof Date ? date : new Date(date);
+  const year = Math.max(1980, d.getFullYear());
+  const time = (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2);
+  const day = ((year - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate();
+  return { time, day };
+}
+
+function u16(view, at, value) {
+  view.setUint16(at, value & 0xffff, true);
+}
+
+function u32(view, at, value) {
+  view.setUint32(at, value >>> 0, true);
+}
+
+/**
+ * Entries are { name, bytes: Uint8Array, date? }. Names are UTF-8 paths with
+ * forward slashes. Returns the zip as a Uint8Array.
+ */
+export function zip(entries, now = new Date()) {
+  const encoder = new TextEncoder();
+  const locals = [];
+  const centrals = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const name = encoder.encode(entry.name.replace(/\\/g, "/"));
+    const bytes = entry.bytes instanceof Uint8Array ? entry.bytes : new Uint8Array(entry.bytes);
+    const crc = crc32(bytes);
+    const { time, day } = dosDateTime(entry.date ?? now);
+
+    const local = new Uint8Array(30 + name.length);
+    const lv = new DataView(local.buffer);
+    u32(lv, 0, 0x04034b50);
+    u16(lv, 4, 20); // version needed
+    u16(lv, 6, 0x0800); // flags: UTF-8 names
+    u16(lv, 8, 0); // stored
+    u16(lv, 10, time);
+    u16(lv, 12, day);
+    u32(lv, 14, crc);
+    u32(lv, 18, bytes.length);
+    u32(lv, 22, bytes.length);
+    u16(lv, 26, name.length);
+    u16(lv, 28, 0);
+    local.set(name, 30);
+    locals.push(local, bytes);
+
+    const central = new Uint8Array(46 + name.length);
+    const cv = new DataView(central.buffer);
+    u32(cv, 0, 0x02014b50);
+    u16(cv, 4, 20); // made by
+    u16(cv, 6, 20); // needed
+    u16(cv, 8, 0x0800);
+    u16(cv, 10, 0);
+    u16(cv, 12, time);
+    u16(cv, 14, day);
+    u32(cv, 16, crc);
+    u32(cv, 20, bytes.length);
+    u32(cv, 24, bytes.length);
+    u16(cv, 28, name.length);
+    u16(cv, 30, 0);
+    u16(cv, 32, 0);
+    u16(cv, 34, 0);
+    u16(cv, 36, 0);
+    u32(cv, 38, 0);
+    u32(cv, 42, offset);
+    central.set(name, 46);
+    centrals.push(central);
+
+    offset += local.length + bytes.length;
+  }
+  const centralSize = centrals.reduce((sum, part) => sum + part.length, 0);
+  const end = new Uint8Array(22);
+  const ev = new DataView(end.buffer);
+  u32(ev, 0, 0x06054b50);
+  u16(ev, 4, 0);
+  u16(ev, 6, 0);
+  u16(ev, 8, entries.length);
+  u16(ev, 10, entries.length);
+  u32(ev, 12, centralSize);
+  u32(ev, 16, offset);
+  u16(ev, 20, 0);
+
+  const total = offset + centralSize + end.length;
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const part of [...locals, ...centrals, end]) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+
+/** The entries of a zip this module wrote (or any stored zip): { name, bytes }. For tests and round trips. */
+export function unzip(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const decoder = new TextDecoder();
+  const entries = [];
+  let at = 0;
+  while (at + 30 <= bytes.length && view.getUint32(at, true) === 0x04034b50) {
+    const method = view.getUint16(at + 8, true);
+    const size = view.getUint32(at + 18, true);
+    const nameLength = view.getUint16(at + 26, true);
+    const extraLength = view.getUint16(at + 28, true);
+    const name = decoder.decode(bytes.subarray(at + 30, at + 30 + nameLength));
+    const start = at + 30 + nameLength + extraLength;
+    if (method !== 0) throw new Error(`unzip: ${name} is not stored`);
+    entries.push({ name, bytes: bytes.subarray(start, start + size) });
+    at = start + size;
+  }
+  return entries;
+}