@hraness/dawg 0.0.0-stage → 0.3.0

package/src/project/typecheck.ts

@@ -0,0 +1,149 @@
+/**
+ * Typechecks a project with the TypeScript compiler dawg depends on.
+ *
+ * TypeScript 7 is a native binary with no JavaScript watch API, so each check
+ * is one `tsc --noEmit --incremental` run whose build info lives in
+ * `.dawg/tsbuild/`; a warm check on a small project takes tens of
+ * milliseconds. Diagnostics come back as `file:line:col message`.
+ */
+
+import { realpathSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Diagnostic } from "../../core/sdk/eval.ts";
+import type { CommandRunner } from "../auth/runner.ts";
+import { systemRunner } from "../auth/runner.ts";
+
+export const TYPECHECK_TIMEOUT_MS = 60_000;
+const MAX_DIAGNOSTICS = 200;
+
+export type TypecheckResult = Readonly<{
+  ok: boolean;
+  diagnostics: readonly Diagnostic[];
+  ms: number;
+}>;
+
+export type TypecheckOptions = Readonly<{
+  runner?: CommandRunner;
+  /** Path of the `tsc` executable; resolved from the dependency by default. */
+  tsc?: string;
+}>;
+
+/** Native `tsc` from `@typescript/typescript-<platform>-<arch>`, else `tsc` on PATH. */
+export function resolveTsc(
+  runner: CommandRunner = systemRunner,
+): string | undefined {
+  const name = `@typescript/typescript-${process.platform}-${process.arch}/package.json`;
+  try {
+    const url = import.meta.resolve(name);
+    return join(dirname(fileURLToPath(url)), "lib", "tsc");
+  } catch {
+    return runner.which("tsc");
+  }
+}
+
+/** Runs `tsc` on `<project>/tsconfig.json` and parses its diagnostics. */
+export async function typecheckProject(
+  project: string,
+  options: TypecheckOptions = {},
+): Promise<TypecheckResult> {
+  const started = performance.now();
+  const runner = options.runner ?? systemRunner;
+  const tsc = options.tsc ?? resolveTsc(runner);
+  if (!tsc)
+    return {
+      ok: false,
+      diagnostics: [{ message: "typescript is not installed (no tsc found)" }],
+      ms: elapsed(started),
+    };
+  const stateDir = join(project, ".dawg", "tsbuild");
+  await mkdir(stateDir, { recursive: true });
+  const result = await runner.run(
+    tsc,
+    [
+      "--noEmit",
+      "--pretty",
+      "false",
+      "--incremental",
+      "--tsBuildInfoFile",
+      join(stateDir, "project.tsbuildinfo"),
+      "-p",
+      join(project, "tsconfig.json"),
+    ],
+    {
+      timeoutMs: TYPECHECK_TIMEOUT_MS,
+      maxOutputBytes: 1024 * 1024,
+      env: { NO_COLOR: "1" },
+    },
+  );
+  if (result.killed)
+    return {
+      ok: false,
+      diagnostics: [{ message: "typecheck timed out" }],
+      ms: elapsed(started),
+    };
+  const diagnostics = parseTscOutput(
+    `${result.stdout}\n${result.stderr}`,
+    project,
+  );
+  if (result.code !== 0 && diagnostics.length === 0)
+    diagnostics.push({
+      message: `tsc exited with code ${result.code}${
+        result.stderr.trim() ? `: ${result.stderr.trim().split("\n")[0]}` : ""
+      }`,
+    });
+  return {
+    ok: result.code === 0 && diagnostics.length === 0,
+    diagnostics,
+    ms: elapsed(started),
+  };
+}
+
+/**
+ * Parses `file(line,col): error TSnnnn: message` lines. tsc prints paths
+ * relative to its working directory; they come back project-relative.
+ */
+export function parseTscOutput(
+  output: string,
+  project: string,
+  cwd: string = process.cwd(),
+): Diagnostic[] {
+  const out: Diagnostic[] = [];
+  const roots = [project];
+  try {
+    roots.push(realpathSync(project));
+  } catch {
+    // An unreadable project keeps the literal path.
+  }
+  const relativize = (file: string): string => {
+    const absolute = isAbsolute(file) ? file : resolve(cwd, file);
+    for (const root of roots) {
+      const rel = relative(root, absolute);
+      if (rel && !rel.startsWith("..") && !isAbsolute(rel)) return rel;
+    }
+    return file;
+  };
+  for (const raw of output.split("\n")) {
+    const line = raw.trimEnd();
+    const match = line.match(/^(.*?)\((\d+),(\d+)\): error (TS\d+): (.*)$/);
+    if (match) {
+      const file = relativize(match[1]!);
+      out.push({
+        file,
+        line: Number(match[2]),
+        col: Number(match[3]),
+        message: `${match[5]} (${match[4]})`,
+      });
+    } else {
+      const bare = line.match(/^error (TS\d+): (.*)$/);
+      if (bare) out.push({ message: `${bare[2]} (${bare[1]})` });
+    }
+    if (out.length >= MAX_DIAGNOSTICS) break;
+  }
+  return out;
+}
+
+function elapsed(started: number): number {
+  return Math.round(performance.now() - started);
+}

package/src/render.ts

@@ -0,0 +1,121 @@
+/**
+ * `dawg render <out.wav>`: renders a session, the project files (`song.ts`,
+ * in a project with no `--session`), or a `track.loop/v1` file to
+ * a stereo 16-bit PCM WAV through the same deterministic renderer playback
+ * uses, so two renders of one score are byte-identical. It reads the session
+ * record from disk and never starts dawgd or plays audio.
+ */
+import { createHash } from "node:crypto";
+import { readFile, rename, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { scoreFromJSON, type TrackScore } from "../core/score.ts";
+import { decodeLoop } from "../core/loop.ts";
+import { renderScoreWav } from "./audio/wav.ts";
+import { SampleLibrary, hasSamplerTracks } from "./audio/samples.ts";
+import { evaluateProject, formatDiagnostic } from "../core/sdk/eval.ts";
+import { isProject } from "./project/init.ts";
+import { resolveSessionArg } from "./session/attach.ts";
+import {
+  loadSession,
+  readCurrentSessionId,
+  sessionPaths,
+} from "./session/store.ts";
+
+export const RENDER_USAGE =
+  "usage: dawg render <out.wav> [--session <name|id>] [--import <file.track.json>]";
+
+const MAX_LOOP_FILE_BYTES = 512 * 1024;
+
+type Output = { write(text: string): unknown };
+
+export async function runRenderCommand(
+  argv: readonly string[],
+  workspace: string,
+  stdout: Output,
+  stderr: Output,
+): Promise<number> {
+  const rest = argv.slice(1);
+  if (rest.includes("--help") || rest.includes("-h")) {
+    stdout.write(`${RENDER_USAGE}\n`);
+    return 0;
+  }
+  const options = new Map<string, string>();
+  const positional: string[] = [];
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index]!;
+    if (arg === "--session" || arg === "--import") {
+      const value = rest[index + 1];
+      if (value === undefined || value.startsWith("--")) {
+        stderr.write(`${arg} needs a value · ${RENDER_USAGE}\n`);
+        return 2;
+      }
+      options.set(arg, value);
+      index += 1;
+    } else if (arg.startsWith("--")) {
+      stderr.write(`unknown option · ${arg} · ${RENDER_USAGE}\n`);
+      return 2;
+    } else positional.push(arg);
+  }
+  const target = positional[0];
+  if (positional.length !== 1 || !target || !/\.wav$/i.test(target)) {
+    stderr.write(`${RENDER_USAGE}\n`);
+    return 2;
+  }
+  let score: TrackScore;
+  try {
+    score = await loadScore(workspace, options);
+  } catch (error) {
+    stderr.write(
+      `render failed · ${error instanceof Error ? error.message : String(error)}\n`,
+    );
+    return 1;
+  }
+  let samples;
+  if (hasSamplerTracks(score)) {
+    samples = await new SampleLibrary({ projectRoot: workspace }).load(score);
+    for (const problem of samples.problems)
+      stderr.write(`sample ${problem.level} · ${problem.message}\n`);
+  }
+  const wav = renderScoreWav(score, { samples });
+  const path = resolve(workspace, target);
+  const temporary = `${path}.${process.pid}.tmp`;
+  await writeFile(temporary, wav);
+  await rename(temporary, path);
+  const sha = createHash("sha256").update(wav).digest("hex");
+  stdout.write(`rendered · ${target} · ${wav.byteLength} bytes · ${sha}\n`);
+  return 0;
+}
+
+async function loadScore(
+  workspace: string,
+  options: ReadonlyMap<string, string>,
+): Promise<TrackScore> {
+  const importPath = options.get("--import");
+  if (importPath !== undefined) {
+    const contents = await readFile(resolve(workspace, importPath));
+    if (contents.byteLength > MAX_LOOP_FILE_BYTES)
+      throw new Error("loop import exceeds 512 KiB");
+    return decodeLoop(contents.toString("utf8"));
+  }
+  const query = options.get("--session");
+  if (query === undefined && (await isProject(workspace))) {
+    const evaluated = await evaluateProject(workspace);
+    if (!evaluated.ok)
+      throw new Error(
+        `${evaluated.diagnostics.map(formatDiagnostic).join("; ").slice(0, 400)} · fix song.ts and retry (dawg check)`,
+      );
+    return evaluated.score;
+  }
+  const sessionId =
+    query === undefined
+      ? await readCurrentSessionId(workspace)
+      : await resolveSessionArg(workspace, query);
+  if (sessionId === undefined)
+    throw new Error("no session here · run dawg first or pass --import");
+  const record = await loadSession<unknown>(
+    sessionPaths(workspace, sessionId),
+  ).catch(() => {
+    throw new Error(`no session named "${query ?? sessionId}" · dawg sessions`);
+  });
+  return scoreFromJSON(record.composition);
+}

package/src/session/attach.ts

@@ -0,0 +1,181 @@
+/**
+ * Glue between the TUI and sessions: resolving `--session <name|id>`,
+ * choosing a track for a newly opened window, materializing draft tracks,
+ * forking, and the auto-namer's port-backed target. Kept out of main.ts so
+ * the entry point only wires these together.
+ */
+import { isDrumInstrument } from "../../core/drums.ts";
+import type { TrackScore } from "../../core/score.ts";
+import {
+  ambiguousSessionMessage,
+  listSessions,
+  resolveSession,
+  type SessionSummary,
+} from "./list.ts";
+import {
+  forkName,
+  normalizeSessionName,
+  uniqueName,
+  type SessionMeta,
+} from "./meta.ts";
+import type { NamingTarget } from "./naming.ts";
+import type { SessionPort } from "./port.ts";
+import {
+  createForkSession,
+  inheritedEvents,
+  setCurrentSession,
+  type SessionEvent,
+  type SessionRecord,
+} from "./store.ts";
+
+export const ALL_TRACKS_OPEN_HINT = "all tracks open · new track";
+
+export class SessionLookupError extends Error {
+  public constructor(message: string) {
+    super(message);
+    this.name = "SessionLookupError";
+  }
+}
+
+/**
+ * Maps `--session <name|id>` to the id of an existing session. An unknown
+ * value throws (a typo must not create a new session; `--new` does that);
+ * an ambiguous name throws with the candidate list.
+ */
+export async function resolveSessionArg(
+  workspace: string,
+  query: string,
+  sessions?: readonly SessionSummary[],
+): Promise<string> {
+  const listed = sessions ?? (await listSessions(workspace));
+  const result = resolveSession(listed, query);
+  if (result.status === "found") return result.session.sessionId;
+  if (result.status === "ambiguous")
+    throw new SessionLookupError(
+      ambiguousSessionMessage(query, result.candidates),
+    );
+  throw new SessionLookupError(`no session named "${query}" · dawg sessions`);
+}
+
+export type TrackAttachment = {
+  trackId: string;
+  /** Reserved id not yet in the score; created on the first edit. */
+  draft: boolean;
+  /** How the track was chosen, for the activity strip. */
+  reason: "explicit" | "claimed" | "draft";
+};
+
+/**
+ * `--track` always wins (focus is published but not exclusive). Otherwise
+ * atomically claim the first track no live window has focused, or a draft.
+ */
+export async function attachTrack<T>(
+  port: SessionPort<T>,
+  score: TrackScore,
+  explicit: string | undefined,
+): Promise<TrackAttachment> {
+  if (explicit !== undefined) {
+    await port.focus(explicit).catch(() => undefined);
+    return { trackId: explicit, draft: false, reason: "explicit" };
+  }
+  const claim = await port.claimOrDraft(score.tracks.map((track) => track.id));
+  return {
+    trackId: claim.trackId,
+    draft: claim.draft,
+    reason: claim.draft ? "draft" : "claimed",
+  };
+}
+
+/** Score with `trackId` present: a draft becomes a real track here. */
+export function withTrack(score: TrackScore, trackId: string): TrackScore {
+  if (score.tracks.some((track) => track.id === trackId)) return score;
+  const draft = trackId.match(/^track-(\d+)$/);
+  return score.withTracks([
+    ...score.tracks,
+    {
+      id: trackId,
+      name: draft ? `track ${draft[1]}` : trackId,
+      instrument: isDrumInstrument(trackId) ? "kit" : "sine",
+    },
+  ]);
+}
+
+/** Copies `source` into a new session named per the fork rules. */
+export async function forkSession<T>(
+  workspace: string,
+  source: SessionRecord<T>,
+  requested: string | undefined,
+): Promise<SessionRecord<T>> {
+  const others = (await listSessions(workspace))
+    .filter((session) => !session.error)
+    .map((session) => session.name);
+  const name =
+    requested !== undefined && requested.trim().length > 0
+      ? uniqueName(normalizeSessionName(requested), others)
+      : forkName(source.meta.name, others);
+  const record = await createForkSession(workspace, source, name);
+  await setCurrentSession(workspace, record.sessionId);
+  return record;
+}
+
+const inheritedCache = new Map<string, Promise<SessionEvent[]>>();
+
+/**
+ * The event log undo/redo replays: the fork ancestry's prefix (see
+ * `inheritedEvents`), then this session's own events. Undo in a fork can
+ * therefore step back past the fork point into the parent's edits. The
+ * inherited prefix never changes, so it is cached per lineage.
+ */
+export async function historyEvents<T>(
+  workspace: string,
+  record: SessionRecord<T>,
+): Promise<SessionEvent[]> {
+  const fork = record.meta.forkOf;
+  if (!fork) return record.events;
+  const key = `${workspace}\0${record.sessionId}\0${fork.sessionId}@${fork.revision}`;
+  let inherited = inheritedCache.get(key);
+  if (!inherited) {
+    inherited = inheritedEvents(workspace, record.meta, record.sessionId);
+    if (inheritedCache.size > 32) inheritedCache.clear();
+    inheritedCache.set(key, inherited);
+  }
+  return [...(await inherited), ...record.events];
+}
+
+/** The auto-namer's view of the live session. */
+export function namingTarget<T>(
+  workspace: string,
+  current: () => { port: SessionPort<T>; record: SessionRecord<T> },
+  adopt: (meta: SessionMeta) => void,
+): NamingTarget {
+  return {
+    meta: () => current().record.meta,
+    updateMeta: async (patch, expect) => {
+      const result = await current().port.updateMeta(patch, expect);
+      adopt(result.meta);
+      return result;
+    },
+    otherNames: async () => {
+      const id = current().record.sessionId;
+      return (await listSessions(workspace))
+        .filter((session) => !session.error && session.sessionId !== id)
+        .map((session) => session.name);
+    },
+  };
+}
+
+/** `/resume` picker text: numbered recent sessions. */
+export function pickerLines(
+  sessions: readonly SessionSummary[],
+  currentId: string,
+  format: (session: SessionSummary) => string,
+  limit = 9,
+): string[] {
+  return sessions
+    .filter((session) => !session.error)
+    .slice(0, limit)
+    .map(
+      (session, index) =>
+        `${index + 1}${session.sessionId === currentId ? "*" : " "} ${format(session)}`,
+    );
+}