cowriter 0.1.0

package/frontend/components/ui.tsx

@@ -0,0 +1,66 @@
+import * as React from "react";
+import { cn } from "@/lib/utils";
+
+export function Button({
+  className,
+  variant = "default",
+  ...props
+}: React.ButtonHTMLAttributes<HTMLButtonElement> & { variant?: "default" | "ghost" | "line" }) {
+  return (
+    <button
+      className={cn(
+        "inline-flex h-9 items-center justify-center gap-2 rounded-md px-3 text-sm font-medium transition duration-200 ease-out active:translate-y-px disabled:pointer-events-none disabled:opacity-45",
+        variant === "default" && "border border-stone-300 bg-[#fffdf8] text-stone-900 shadow-[0_12px_28px_-24px_rgba(87,83,78,0.55)] hover:border-stone-400 hover:bg-stone-100",
+        variant === "ghost" && "text-stone-600 hover:bg-stone-100 hover:text-stone-950",
+        variant === "line" && "border border-stone-300 bg-white text-stone-800 hover:border-stone-400 hover:bg-stone-50",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export function Input({ className, ...props }: React.InputHTMLAttributes<HTMLInputElement>) {
+  return (
+    <input
+      className={cn(
+        "h-10 w-full rounded-md border border-stone-300 bg-[#fffdf8] px-3 text-sm text-stone-900 outline-none transition placeholder:text-stone-400 focus:border-amber-700",
+        className,
+      )}
+      {...props}
+    />
+  );
+}
+
+export const Textarea = React.forwardRef<HTMLTextAreaElement, React.TextareaHTMLAttributes<HTMLTextAreaElement>>(
+  function Textarea({ className, ...props }, ref) {
+    return (
+      <textarea
+        ref={ref}
+        className={cn(
+          "min-h-28 w-full resize-y rounded-md border border-stone-300 bg-[#fffdf8] px-3 py-2 text-sm leading-6 text-stone-900 outline-none transition placeholder:text-stone-400 focus:border-amber-700",
+          className,
+        )}
+        {...props}
+      />
+    );
+  },
+);
+
+export function Field({
+  label,
+  helper,
+  children,
+}: {
+  label: string;
+  helper?: string;
+  children: React.ReactNode;
+}) {
+  return (
+    <label className="grid gap-2">
+      <span className="text-xs font-medium uppercase text-stone-500">{label}</span>
+      {children}
+      {helper ? <span className="text-xs text-stone-500">{helper}</span> : null}
+    </label>
+  );
+}

package/frontend/lib/highlight.ts

@@ -0,0 +1,53 @@
+export type TextMatch = {
+  start: number;
+  end: number;
+};
+
+function normalizedTextWithMap(value: string) {
+  let text = "";
+  const map: number[] = [];
+  let previousWasWhitespace = false;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (/\s/.test(character)) {
+      if (!previousWasWhitespace) {
+        text += " ";
+        map.push(index);
+        previousWasWhitespace = true;
+      }
+      continue;
+    }
+
+    text += character;
+    map.push(index);
+    previousWasWhitespace = false;
+  }
+
+  return { text: text.trim(), map, leadingTrimmed: text.length - text.trimStart().length };
+}
+
+export function findNormalizedTextMatch(source: string, target: string, occurrence = 1): TextMatch | null {
+  const requestedOccurrence = Math.max(1, Math.trunc(occurrence));
+  const normalizedSource = normalizedTextWithMap(source);
+  const normalizedTarget = target.trim().replace(/\s+/g, " ");
+  if (!normalizedSource.text || !normalizedTarget) return null;
+
+  let searchFrom = 0;
+  let seen = 0;
+  while (searchFrom <= normalizedSource.text.length) {
+    const index = normalizedSource.text.indexOf(normalizedTarget, searchFrom);
+    if (index === -1) return null;
+    seen += 1;
+    if (seen === requestedOccurrence) {
+      const sourceMapStart = index + normalizedSource.leadingTrimmed;
+      const sourceMapEnd = sourceMapStart + normalizedTarget.length - 1;
+      const start = normalizedSource.map[sourceMapStart];
+      const end = normalizedSource.map[sourceMapEnd] + 1;
+      return typeof start === "number" && typeof end === "number" ? { start, end } : null;
+    }
+    searchFrom = index + normalizedTarget.length;
+  }
+
+  return null;
+}

package/frontend/lib/markdown.ts

@@ -0,0 +1,47 @@
+import { marked } from "marked";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+
+const turndown = new TurndownService({
+  headingStyle: "atx",
+  bulletListMarker: "-",
+  codeBlockStyle: "fenced",
+});
+turndown.use(gfm);
+
+export function markdownToHtml(markdown: string) {
+  return marked.parse(markdown, { async: false, breaks: false }) as string;
+}
+
+export function htmlToMarkdown(html: string) {
+  return turndown.turndown(html).trim() + "\n";
+}
+
+export function plainTextFromMarkdown(markdown: string) {
+  return markdown
+    .replace(/^[ \t]*\|?[ \t]*:?-{3,}:?[ \t]*(\|[ \t]*:?-{3,}:?[ \t]*)+\|?[ \t]*$(?:\r?\n)?/gm, "")
+    .replace(/^[ \t]*\|(.+)\|[ \t]*$/gm, (_row, cells: string) => cells.split("|").map((cell) => cell.trim()).filter(Boolean).join(" "))
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/^>[ \t]?/gm, "")
+    .replace(/[*_`>#|-]/g, "")
+    .replace(/\[(.*?)\]\(.*?\)/g, "$1")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+export function paginateText(text: string, pageSize = 1750) {
+  const clean = text.trim();
+  if (!clean) return [""];
+  const pages: string[] = [];
+  let cursor = 0;
+  while (cursor < clean.length) {
+    let end = Math.min(cursor + pageSize, clean.length);
+    if (end < clean.length) {
+      const breakAt = Math.max(clean.lastIndexOf("\n\n", end), clean.lastIndexOf(". ", end));
+      if (breakAt > cursor + pageSize * 0.55) end = breakAt + 1;
+    }
+    pages.push(clean.slice(cursor, end).trim());
+    cursor = end;
+  }
+  return pages.length ? pages : [""];
+}

package/frontend/lib/project.ts

@@ -0,0 +1,335 @@
+import YAML from "yaml";
+import { z } from "zod";
+import type {
+  Chapter,
+  CharacterRecord,
+  CodexAction,
+  CodexChatRequest,
+  CodexChatResponse,
+  CowriterProject,
+  CowriterReportContent,
+  OutlineBeat,
+  StoryBible,
+} from "./types";
+
+const starterChapterText = "";
+const starterSynopsis = "";
+const legacyStarterChapterText =
+  "Opening\n\nThe first page waits here. Write into the book, select a passage, then ask Codex to revise, expand, or test it against the story bible.";
+const legacyStarterSynopsis = "A rough promise for the book belongs here.";
+
+export const storySchema = z.object({
+  title: z.string(),
+  synopsis: z.string(),
+  setting: z.string(),
+  themes: z.string(),
+  genre: z.string(),
+  tone: z.string(),
+  perspective: z.string(),
+  continuity: z.string(),
+});
+
+export const characterSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  role: z.string(),
+  desire: z.string(),
+  conflict: z.string(),
+  notes: z.string(),
+});
+
+export const outlineBeatSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  summary: z.string(),
+});
+
+export const reportSchema = z.object({
+  id: z.string(),
+  path: z.string(),
+  type: z.string(),
+  title: z.string(),
+  status: z.string(),
+  createdAt: z.string(),
+  chapter: z.string().optional(),
+});
+
+export const reportContentSchema = z.object({
+  path: z.string(),
+  markdown: z.string(),
+});
+
+export const coverSchema = z.object({
+  path: z.string(),
+  contentType: z.string(),
+  updatedAt: z.string(),
+});
+
+const replaceSelectionActionSchema = z.object({
+  type: z.literal("replace-selection"),
+  markdown: z.string(),
+});
+
+const insertAtCursorActionSchema = z.object({
+  type: z.literal("insert-at-cursor"),
+  markdown: z.string(),
+});
+
+const replaceChapterActionSchema = z.object({
+  type: z.literal("replace-chapter"),
+  chapterId: z.string(),
+  markdown: z.string(),
+});
+
+const updateStoryFieldsActionSchema = z.object({
+  type: z.literal("update-story-fields"),
+  fields: storySchema.partial(),
+});
+
+const upsertCharacterActionSchema = z.object({
+  type: z.literal("upsert-character"),
+  character: characterSchema,
+});
+
+const updateOutlineBeatActionSchema = z.object({
+  type: z.literal("update-outline-beat"),
+  beat: outlineBeatSchema,
+});
+
+export const codexActionSchema = z.discriminatedUnion("type", [
+  replaceSelectionActionSchema,
+  insertAtCursorActionSchema,
+  replaceChapterActionSchema,
+  updateStoryFieldsActionSchema,
+  upsertCharacterActionSchema,
+  updateOutlineBeatActionSchema,
+]);
+
+export const codexChatResponseSchema = z.object({
+  message: z.string(),
+  actions: z.array(codexActionSchema).optional(),
+  skillIdsUsed: z.array(z.string()).optional(),
+  changedPaths: z.array(z.string()).optional(),
+  project: z.custom<CowriterProject>().optional(),
+});
+
+export function createStarterProject(path: string, title = "Untitled Book"): CowriterProject {
+  const now = new Date().toISOString();
+  const cleanTitle = title.trim();
+  const metadataTitle = cleanTitle || "Untitled Book";
+  return {
+    path,
+    metadata: { title: metadataTitle, author: "Local Writer", createdAt: now },
+    activeChapterId: "001-opening",
+    chapters: [
+      {
+        id: "001-opening",
+        title: "Opening",
+        path: "chapters/001-opening.md",
+        markdown: "",
+        updatedAt: now,
+      },
+    ],
+    story: {
+      title: cleanTitle,
+      synopsis: "",
+      setting: "",
+      themes: "",
+      genre: "",
+      tone: "",
+      perspective: "",
+      continuity: "",
+    },
+    characters: [
+      {
+        id: "primary-character",
+        name: "",
+        role: "",
+        desire: "",
+        conflict: "",
+        notes: "",
+      },
+    ],
+    outline: [
+      {
+        id: "opening-beat",
+        title: "",
+        summary: "",
+      },
+    ],
+    cover: null,
+    reports: [],
+    git: { dirty: false, changedPaths: [] },
+  };
+}
+
+export function encodeSidecars(project: CowriterProject) {
+  return {
+    "story.yaml": YAML.stringify(project.story),
+    "outline.yaml": YAML.stringify({ beats: project.outline }),
+    ".cowriter/project.yaml": YAML.stringify(project.metadata),
+    characters: Object.fromEntries(
+      project.characters.map((character) => [`characters/${character.id}.yaml`, YAML.stringify(character)]),
+    ),
+  };
+}
+
+export function validateProject(project: CowriterProject) {
+  storySchema.parse(project.story);
+  project.characters.forEach((character) => characterSchema.parse(character));
+  project.outline.forEach((beat) => outlineBeatSchema.parse(beat));
+  if (project.cover) coverSchema.parse(project.cover);
+  project.reports.forEach((report) => reportSchema.parse(report));
+  return project;
+}
+
+export function validateCodexChatResponse(response: CodexChatResponse) {
+  const parsed = codexChatResponseSchema.parse(response);
+  if (parsed.project) validateProject(parsed.project);
+  return parsed;
+}
+
+export function isBookEmpty(project: Pick<CowriterProject, "chapters" | "story">) {
+  const hasManuscript = project.chapters.some((chapter) => {
+    const text = plainTextFromMarkdown(chapter.markdown);
+    return text.length > 0 && text !== starterChapterText && text !== legacyStarterChapterText;
+  });
+  const synopsis = project.story.synopsis.trim();
+  const hasSynopsis = synopsis.length > 0 && synopsis !== starterSynopsis && synopsis !== legacyStarterSynopsis;
+  return !hasManuscript && !hasSynopsis;
+}
+
+export function nextWritingTaskPrompt(project: Pick<CowriterProject, "chapters" | "story">) {
+  if (isBookEmpty(project)) {
+    return "";
+  }
+  const synopsis = project.story.synopsis.trim();
+  if (!synopsis || synopsis === starterSynopsis || synopsis === legacyStarterSynopsis) {
+    return "Next writing task: write a rough synopsis so the manuscript has a clear dramatic promise.";
+  }
+  const hasManuscript = project.chapters.some((chapter) => {
+    const text = plainTextFromMarkdown(chapter.markdown);
+    return text.length > 0 && text !== starterChapterText && text !== legacyStarterChapterText;
+  });
+  if (!hasManuscript) return "Next writing task: draft the opening page from the synopsis.";
+  return "Next writing task: choose the next passage, scene beat, or story-bible note to develop.";
+}
+
+function looksLikeSynopsis(message: string) {
+  return message.trim().split(/\s+/).filter(Boolean).length >= 18;
+}
+
+async function cowriterApi<T>(body?: unknown): Promise<T | null> {
+  if (typeof window === "undefined") return null;
+  try {
+    const response = await fetch("/api/cowriter", body ? {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    } : { cache: "no-store" });
+    if (!response.ok) return null;
+    const json = await response.json();
+    if (json?.error) return null;
+    return json as T;
+  } catch {
+    return null;
+  }
+}
+
+export async function readActiveProject() {
+  const response = await cowriterApi<{ activeProject: CowriterProject | null }>();
+  if (response?.activeProject) {
+    return validateProject(response.activeProject);
+  }
+  return null;
+}
+
+export async function readReport(path: string): Promise<CowriterReportContent> {
+  const response = await cowriterApi<{ report: CowriterReportContent }>({ command: "read-report", path });
+  if (!response?.report) throw new Error("Cowriter report API unavailable.");
+  return reportContentSchema.parse(response.report);
+}
+
+function requireProject(response: { project?: CowriterProject } | null) {
+  if (!response?.project) throw new Error("Cowriter project API unavailable.");
+  return validateProject(response.project);
+}
+
+export async function writeChapter(project: CowriterProject, chapter: Chapter) {
+  const response = await cowriterApi<{ project: CowriterProject }>({ command: "write-chapter", chapter });
+  return requireProject(response);
+}
+
+export async function writeStory(project: CowriterProject, story: StoryBible) {
+  const response = await cowriterApi<{ project: CowriterProject }>({ command: "write-story", story });
+  return requireProject(response);
+}
+
+export async function writeCharacters(project: CowriterProject, characters: CharacterRecord[]) {
+  const response = await cowriterApi<{ project: CowriterProject }>({ command: "write-characters", characters });
+  return requireProject(response);
+}
+
+export async function writeOutline(project: CowriterProject, outline: OutlineBeat[]) {
+  const response = await cowriterApi<{ project: CowriterProject }>({ command: "write-outline", outline });
+  return requireProject(response);
+}
+
+export async function sendCodexChat(request: CodexChatRequest, projectPath?: string): Promise<CodexChatResponse> {
+  const lowerMessage = request.message.toLowerCase();
+  const selected = request.context.selectedText?.trim();
+  const actions: CodexAction[] = [];
+  const contextProject = {
+    chapters: request.context.activeChapter ? [request.context.activeChapter] : [],
+    story: request.context.story,
+  };
+  const emptyBook = isBookEmpty(contextProject);
+  const nextProject = {
+    ...contextProject,
+    story: { ...contextProject.story, synopsis: request.message.trim() },
+  };
+
+  if (selected && /\b(rewrite|tighten|polish|dialogue|tone|expand)\b/.test(lowerMessage)) {
+    actions.push({
+      type: "replace-selection",
+      markdown: `${selected}\n\nThe passage can be revised here once the Cowriter skill is connected through Codex.app.`,
+    });
+  }
+
+  if (emptyBook && looksLikeSynopsis(request.message)) {
+    actions.push({
+      type: "update-story-fields",
+      fields: { synopsis: request.message.trim() },
+    });
+  }
+
+  const target = selected
+    ? "the selected text"
+    : request.context.activeStoryTab === "characters"
+      ? "the character bible"
+      : request.context.activeStoryTab === "outline"
+        ? "the outline"
+        : request.context.activeStoryTab === "story"
+          ? "the story bible"
+          : "the current page";
+
+  return validateCodexChatResponse({
+    message: `${emptyBook && looksLikeSynopsis(request.message)
+        ? "This reads like a workable synopsis. Ask Codex to save it to story.yaml in the project folder."
+      : emptyBook
+        ? "This book is still empty. Share a one-paragraph synopsis first, even if it is rough."
+        : `Cowriter packaged your request for ${target}. In Codex.app, the Cowriter skill can inspect the local project and edit manuscript or story-bible files directly.`} ${nextWritingTaskPrompt(emptyBook && looksLikeSynopsis(request.message) ? nextProject : contextProject)}`,
+    actions,
+    skillIdsUsed: emptyBook && looksLikeSynopsis(request.message) ? ["synopsis-expansion"] : selected ? ["rewrite-selection"] : ["continuity-review"],
+    changedPaths: emptyBook && looksLikeSynopsis(request.message) ? ["story.yaml"] : [],
+  });
+}
+
+function plainTextFromMarkdown(markdown: string) {
+  return markdown
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/[*_`>#-]/g, "")
+    .replace(/\[(.*?)\]\(.*?\)/g, "$1")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}

package/frontend/lib/skills.ts

@@ -0,0 +1,15 @@
+import skills from "./writing-skills.json";
+
+export type WritingSkill = {
+  id: string;
+  label: string;
+  target: "selection" | "story-bible" | "chat";
+  description: string;
+  instruction: string;
+};
+
+export const writingSkills = skills as WritingSkill[];
+
+export function skillById(id: string) {
+  return writingSkills.find((skill) => skill.id === id) ?? writingSkills[0];
+}

package/frontend/lib/turndown-plugin-gfm.d.ts

@@ -0,0 +1,5 @@
+declare module "turndown-plugin-gfm" {
+  import type TurndownService from "turndown";
+
+  export function gfm(service: TurndownService): void;
+}

package/frontend/lib/types.ts

@@ -0,0 +1,143 @@
+export type Chapter = {
+  id: string;
+  title: string;
+  path: string;
+  markdown: string;
+  updatedAt: string;
+};
+
+export type CharacterRecord = {
+  id: string;
+  name: string;
+  role: string;
+  desire: string;
+  conflict: string;
+  notes: string;
+};
+
+export type StoryBible = {
+  title: string;
+  synopsis: string;
+  setting: string;
+  themes: string;
+  genre: string;
+  tone: string;
+  perspective: string;
+  continuity: string;
+};
+
+export type OutlineBeat = {
+  id: string;
+  title: string;
+  summary: string;
+};
+
+export type GitStatus = {
+  dirty: boolean;
+  changedPaths: string[];
+  lastCommit?: string;
+  lastCommitAt?: string;
+};
+
+export type CowriterCover = {
+  path: string;
+  contentType: string;
+  updatedAt: string;
+};
+
+export type CowriterReport = {
+  id: string;
+  path: string;
+  type: string;
+  title: string;
+  status: string;
+  createdAt: string;
+  chapter?: string;
+};
+
+export type CowriterReportContent = {
+  path: string;
+  markdown: string;
+};
+
+export type CowriterProject = {
+  path: string;
+  metadata: {
+    title: string;
+    author: string;
+    createdAt: string;
+  };
+  activeChapterId: string;
+  chapters: Chapter[];
+  story: StoryBible;
+  characters: CharacterRecord[];
+  outline: OutlineBeat[];
+  cover: CowriterCover | null;
+  reports: CowriterReport[];
+  git: GitStatus;
+};
+
+export type ChatMessage = { role: "writer" | "codex"; content: string };
+
+export type CodexChatContext = {
+  activeChapter?: Chapter;
+  activePage?: string;
+  selectedText?: string;
+  activeStoryTab?: "story" | "characters" | "outline" | "reports";
+  story: StoryBible;
+  characters: CharacterRecord[];
+  outline: OutlineBeat[];
+};
+
+export type ReplaceSelectionAction = {
+  type: "replace-selection";
+  markdown: string;
+};
+
+export type InsertAtCursorAction = {
+  type: "insert-at-cursor";
+  markdown: string;
+};
+
+export type ReplaceChapterAction = {
+  type: "replace-chapter";
+  chapterId: string;
+  markdown: string;
+};
+
+export type UpdateStoryFieldsAction = {
+  type: "update-story-fields";
+  fields: Partial<StoryBible>;
+};
+
+export type UpsertCharacterAction = {
+  type: "upsert-character";
+  character: CharacterRecord;
+};
+
+export type UpdateOutlineBeatAction = {
+  type: "update-outline-beat";
+  beat: OutlineBeat;
+};
+
+export type CodexAction =
+  | ReplaceSelectionAction
+  | InsertAtCursorAction
+  | ReplaceChapterAction
+  | UpdateStoryFieldsAction
+  | UpsertCharacterAction
+  | UpdateOutlineBeatAction;
+
+export type CodexChatRequest = {
+  message: string;
+  history: ChatMessage[];
+  context: CodexChatContext;
+};
+
+export type CodexChatResponse = {
+  message: string;
+  actions?: CodexAction[];
+  skillIdsUsed?: string[];
+  changedPaths?: string[];
+  project?: CowriterProject;
+};

package/frontend/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}