@worca/app 1.0.0 → 1.2.0-rc.1

package/src/core/ask/attachment-kind.mjs

@@ -0,0 +1,95 @@
+// src/core/ask/attachment-kind.mjs
+// Attachment typing for the Ask Worca chat (issue #398): which extensions are
+// accepted, what kind/mime each maps to, and content sniffing for the binary
+// ones. Pure and synchronous — the single source of truth for the type table;
+// limits.mjs re-exports the two extension lists and ui/server.mjs validates
+// uploads with classifyExtension + sniffMime.
+//
+// Kinds: 'text' (UTF-8, inlineable into the turn prompt, redactable),
+// 'image' (fed to the model via its Read tool on the stored file) and
+// 'binary' (today only PDF — same Read-tool path, never inlined).
+//
+// The extension names the CLAIMED type; for binary kinds the claim is verified
+// against the leading bytes (magic number) so a mislabeled body is refused at
+// upload rather than stored wrong. SVG is deliberately absent: it is scriptable
+// markup, and the download route serves attachment bodies with their real mime.
+
+/** Extension -> {kind, mime} for the text kinds (the pre-#398 allowlist). */
+const TEXT_TYPES = Object.freeze({
+  '.md': 'text/markdown',
+  '.markdown': 'text/markdown',
+  '.txt': 'text/plain',
+  '.json': 'application/json',
+  '.csv': 'text/csv',
+  '.log': 'text/plain',
+});
+
+/** Extension -> mime for the binary kinds. Every mime here MUST be sniffable. */
+const BINARY_TYPES = Object.freeze({
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.pdf': 'application/pdf',
+});
+
+export const TEXT_EXTENSIONS = Object.freeze(Object.keys(TEXT_TYPES));
+export const BINARY_EXTENSIONS = Object.freeze(Object.keys(BINARY_TYPES));
+
+const kindForMime = (mime) => (mime.startsWith('image/') ? 'image' : 'binary');
+
+/** ISO 32000-1 §7.5.2 (implementation note 13): the `%PDF-` header may be
+ *  preceded by up to 1024 bytes of junk (a UTF-8 BOM, print-driver or mail-
+ *  gateway preamble). Acrobat and pdf.js accept such files, so the sniff does too. */
+const PDF_HEADER_WINDOW = 1024;
+
+/**
+ * Classify a lower-cased extension (with the leading dot) into {kind, mime},
+ * or null when it is not on either allowlist.
+ */
+export function classifyExtension(ext) {
+  if (typeof ext !== 'string') return null;
+  const e = ext.toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(TEXT_TYPES, e)) return { kind: 'text', mime: TEXT_TYPES[e] };
+  if (Object.prototype.hasOwnProperty.call(BINARY_TYPES, e)) return { kind: kindForMime(BINARY_TYPES[e]), mime: BINARY_TYPES[e] };
+  return null;
+}
+
+/**
+ * Sniff the real mime of a binary body from its magic number, or null when the
+ * bytes match none of the accepted binary types. Text kinds are validated by
+ * UTF-8 decoding instead (ui/server.mjs), never sniffed here.
+ */
+export function sniffMime(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 3) return null;
+  if (buf.length >= 8
+    && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47
+    && buf[4] === 0x0d && buf[5] === 0x0a && buf[6] === 0x1a && buf[7] === 0x0a) return 'image/png';
+  // SOI (FF D8) followed by the first marker's FF and its marker byte (>= 0xC0:
+  // APPn/DQT/SOFn/…) — a bare 3-byte FF D8 FF stub is not a JPEG anything can open.
+  if (buf.length >= 4 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff && buf[3] >= 0xc0) return 'image/jpeg';
+  if (buf.length >= 6) {
+    const head6 = buf.toString('latin1', 0, 6);
+    if (head6 === 'GIF87a' || head6 === 'GIF89a') return 'image/gif';
+  }
+  if (buf.length >= 12
+    && buf.toString('latin1', 0, 4) === 'RIFF'
+    && buf.toString('latin1', 8, 12) === 'WEBP') return 'image/webp';
+  if (buf.length >= 5) {
+    const at = buf.toString('latin1', 0, Math.min(buf.length, PDF_HEADER_WINDOW + 5)).indexOf('%PDF-');
+    if (at !== -1 && at <= PDF_HEADER_WINDOW) return 'application/pdf';
+  }
+  return null;
+}
+
+/** The on-disk extension for a stored body: derived from the SNIFFED mime (or
+ *  '.txt' for text kinds), never from the user-supplied name — the path stays a
+ *  function of row data the store minted (store.mjs traversal guard). */
+export function extensionForAttachment(kind, mime) {
+  if (kind === 'text' || kind == null) return '.txt';
+  for (const [ext, m] of Object.entries(BINARY_TYPES)) {
+    if (m === mime) return ext; // first match: '.jpg' wins over '.jpeg' for image/jpeg
+  }
+  return '.bin';
+}

package/src/core/ask/catalog.mjs

@@ -0,0 +1,111 @@
+// src/core/ask/catalog.mjs
+// The static catalog the assistant sees (ask-worca-design.md §6.1, D9): projects,
+// workspaces and workflows with their ordered step groups. ONE builder feeds both
+// the system prompt (prompt.mjs renders a subset) and the list_projects /
+// list_workflows tools (tools.mjs returns the objects) — never two readers.
+// Readers are injected so unit tests run without a DB.
+import { listProjects as realListProjects } from '../projects.mjs';
+import { listWorkspaces as realListWorkspaces } from '../workspaces.mjs';
+import { listWorkflows as realListWorkflows, GRAPH_DEFAULT_WORKFLOW } from '../workflows.mjs';
+import { classifyLoops } from '../../shared/graph/loops.mjs';
+import { rankNodes } from '../../shared/graph/layout.mjs';
+import { registryPortsFn } from '../graph/registry-ports.mjs';
+
+/** A v2 graph -> the v1-shaped step groups the assistant already understands:
+ *  one group per rank (loop wires excluded), agent nodes only. */
+function graphSteps(tpl, portsFn) {
+  const ranks = rankNodes(tpl, classifyLoops(tpl, portsFn));
+  const byRank = new Map();
+  for (const node of tpl.nodes) {
+    // buildCatalog maps EVERY template, so one malformed node used to take down
+    // the whole Ask system prompt and list_workflows, not just its own row.
+    if (!node || node.kind !== 'agent') continue;
+    const r = ranks[node.id] ?? 0;
+    if (!byRank.has(r)) byRank.set(r, []);
+    byRank.get(r).push(node);
+  }
+  return [...byRank.keys()].sort((a, b) => a - b).map((r) => byRank.get(r));
+}
+import { loadAgentRegistry as realLoadAgentRegistry } from '../agent-registry.mjs';
+
+/**
+ * Pure: a stored workflow template → the catalog shape. `tpl.steps` is already
+ * Array<Array<{id,key}>> (outer = ordered step groups, inner = parallel nodes,
+ * workflows.mjs:93-111 / :208-220), so this is a straight map against the agent
+ * registry for display names; unknown keys fall back to the key itself.
+ */
+export function shapeWorkflow(tpl, registry = {}) {
+  if (tpl && tpl.version === 2 && Array.isArray(tpl.nodes)) {
+    const portsFn = registryPortsFn(registry);
+    const groups = graphSteps(tpl, portsFn);
+    const { loopWireIds } = classifyLoops(tpl, portsFn);
+    return {
+      id: tpl.id,
+      name: tpl.name,
+      domain: typeof tpl.domain === 'string' && tpl.domain ? tpl.domain : 'general',
+      origin: tpl.origin ?? null,
+      steps: groups.map((group) => group.map((node) => {
+        const meta = registry && registry[node.key] ? registry[node.key] : null;
+        return {
+          nodeId: node.id,
+          key: node.key,
+          displayName: meta && meta.displayName ? meta.displayName : node.key,
+          description: meta && typeof meta.description === 'string' ? meta.description : '',
+        };
+      })),
+      feedbacks: (tpl.wires || []).filter((w) => w && loopWireIds.has(w.id))
+        .map((w) => ({ id: w.id, from: w.from.node, to: w.to.node })),
+    };
+  }
+  const steps = Array.isArray(tpl.steps) ? tpl.steps : [];
+  const feedbacks = Array.isArray(tpl.feedbacks) ? tpl.feedbacks : [];
+  return {
+    id: tpl.id,
+    name: tpl.name,
+    domain: typeof tpl.domain === 'string' && tpl.domain ? tpl.domain : 'general',
+    origin: tpl.origin ?? null,
+    steps: steps.map((group) => (Array.isArray(group) ? group : []).map((node) => {
+      const meta = registry && node && registry[node.key] ? registry[node.key] : null;
+      return {
+        nodeId: node.id,
+        key: node.key,
+        displayName: meta && typeof meta.displayName === 'string' && meta.displayName ? meta.displayName : node.key,
+        description: meta && typeof meta.description === 'string' ? meta.description : '',
+      };
+    })),
+    feedbacks: feedbacks.map((f) => ({ id: f.id, from: f.from, to: f.to })),
+  };
+}
+
+/**
+ * @param {{listProjects?:Function, listWorkspaces?:Function, listWorkflows?:Function, defaultWorkflow?:object, loadAgentRegistry?:Function}} [deps]
+ */
+export function createCatalog({
+  listProjects = realListProjects,
+  listWorkspaces = realListWorkspaces,
+  listWorkflows = realListWorkflows,
+  defaultWorkflow = GRAPH_DEFAULT_WORKFLOW,
+  loadAgentRegistry = realLoadAgentRegistry,
+} = {}) {
+  async function buildCatalog() {
+    const [projects, workspaces, workflows] = await Promise.all([listProjects(), listWorkspaces(), listWorkflows()]);
+    let registry = {};
+    try { registry = loadAgentRegistry() || {}; } catch { registry = {}; }
+    // Same order as GET /api/workflows: the graph default, then saved rows.
+    // shapeWorkflow already derives `steps` (condensation-topo ranks) +
+    // `feedbacks` (loop wires) for a v2 template, so the LLM-facing shape is unchanged.
+    const templates = [
+      defaultWorkflow,
+      ...workflows.filter((t) => t && t.id !== defaultWorkflow.id),
+    ];
+    return {
+      projects: projects.map((p) => ({ key: p.key, name: p.name, path: p.path })),
+      workspaces: workspaces.map((w) => ({ id: w.id, name: w.name, projectKeys: [...(w.projectKeys || [])] })),
+      workflows: templates.map((t) => shapeWorkflow(t, registry)),
+    };
+  }
+  return { buildCatalog };
+}
+
+/** Bound to the real readers — what the server and the MCP child use. */
+export const buildCatalog = createCatalog().buildCatalog;

package/src/core/ask/comment-deps.mjs

@@ -0,0 +1,55 @@
+// src/core/ask/comment-deps.mjs
+// The WRITE-CAPABLE dep bundle of the diff-comment tools. Deliberately separate
+// from tool-deps.mjs, whose source is scanned as read-only
+// (test/ask-tools.test.mjs): every row that is created, resolved or deleted is
+// reachable ONLY through here, and test/ask-diff-comment-tools.test.mjs pins this
+// module's import surface. Same shape as worktree-deps.mjs — one namespaced
+// sub-object.
+//
+// Everything writes through src/core/diff-comments.mjs — the one mutation module —
+// so the MCP path and the REST path share anchor validation, the body cap and the
+// change notification. Reads add the surrounding hunk lines here (tools.mjs has no
+// imports at all); tools.mjs owns the protected-path filter and the redaction, so
+// the fail-closed read rules live next to get_run_diff's.
+import {
+  addDiffComment, listDiffComments, getDiffComment, setDiffCommentResolved, deleteDiffComment,
+} from '../diff-comments.mjs';
+import { hunkContext } from '../diff-anchor.mjs';
+
+/** Rows either side of an anchor served to the model. */
+export const COMMENT_CONTEXT_RADIUS = 3;
+
+// COST NOTE, deliberate: hunkContext() re-runs splitPatchSections + patchIndex +
+// parseFileSection over the WHOLE patch once per comment, so listing N comments
+// on a run costs N full parses. That is the price of using the ONE parser (D3)
+// instead of a second, faster, divergent one. It is bounded in practice — this
+// runs in the MCP child, once per tool call, on runs with a handful of comments
+// — and the REST list path does not do it at all. If a real run ever makes this
+// hurt, memoize the parsed index per (patchText) inside this closure; do NOT
+// hand-roll a cheaper scan.
+
+/** No thread scoping: comments belong to RUNS, not to chat threads. */
+export function defaultCommentDeps() {
+  return {
+    comments: {
+      /** Comments of a run, each with `context` when the patch is readable.
+       *  `keep` is the CALLER's protected-path filter (tools.mjs owns the guard
+       *  rules); applied BEFORE the context parse so a row that will be dropped
+       *  never costs a whole-patch parse, and so the order is fail-closed-first
+       *  like everywhere else. */
+      list: (storeKey, pipelineId, { status = 'all', path = null, patchText = null, keep = null } = {}) => {
+        const rows = listDiffComments(storeKey, pipelineId, { status, path });
+        const kept = typeof keep === 'function' ? rows.filter(keep) : rows;
+        return kept.map((c) => (patchText == null ? c : {
+          ...c,
+          context: hunkContext(patchText, { project: c.projectKey, path: c.path, side: c.side, line: c.line },
+            COMMENT_CONTEXT_RADIUS),
+        }));
+      },
+      add: (input) => addDiffComment({ ...input, author: 'ask' }),
+      get: (id) => getDiffComment(id),
+      setResolved: (id, resolved) => setDiffCommentResolved(id, resolved),
+      remove: (id) => deleteDiffComment(id),
+    },
+  };
+}