@nema-project/nema 0.1.4 → 0.1.5

package/dist/chunks/{chunk-HEIQINX3.js → chunk-XDIAG2QH.js}

@@ -32,12 +32,49 @@ var Implementation = z.object({
 });
 
 // ../../../packages/shared/dist/entry.js
+import { z as z3 } from "zod";
+
+// ../../../packages/shared/dist/sourceEvidence.js
 import { z as z2 } from "zod";
+var NoControls = /^[^\x00-\x1f\x7f]*$/;
+var SourceRevision = z2.string().min(1).max(256).regex(NoControls).nullable();
+var SnapshotHash = z2.string().regex(/^[0-9a-f]{64}$/);
+var SourceExcerpt = z2.object({
+  locator: z2.string().min(1).max(200),
+  text: z2.string().min(1).max(2e3)
+});
+var SourceSnapshot = z2.object({
+  schemaVersion: z2.literal(1),
+  provider: z2.string().regex(/^[a-z][a-z0-9_-]{0,63}$/),
+  resourceId: z2.string().min(1).max(512).regex(NoControls).refine((value) => value.trim() === value, "resourceId must not have surrounding whitespace"),
+  revision: SourceRevision,
+  fetchedAt: z2.iso.datetime({ offset: true }),
+  title: z2.string().min(1).max(200),
+  canonicalUrl: z2.string().refine((value) => {
+    try {
+      const url = new URL(value);
+      return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+    } catch {
+      return false;
+    }
+  }, "canonicalUrl must be http or https without user information").nullable(),
+  contentHash: SnapshotHash,
+  excerpts: z2.array(SourceExcerpt).min(1).max(20).refine((excerpts) => excerpts.reduce((total, excerpt) => total + excerpt.text.length, 0) <= 8e3, "excerpt text must total at most 8000 characters")
+});
+var SourceRef = z2.object({
+  sourceEntryId: z2.string().regex(/^S-[1-9]\d*$/),
+  revision: SourceRevision,
+  snapshotHash: SnapshotHash,
+  locator: z2.string().min(1).max(200).optional(),
+  quote: z2.string().min(1).max(500).optional()
+}).refine((ref) => ref.quote === void 0 || ref.locator !== void 0, { path: ["locator"], message: "locator is required with quote" });
+
+// ../../../packages/shared/dist/entry.js
 var ENTRY_KINDS = ["requirement", "decision", "tradeoff", "question", "source", "diagram", "workpackage"];
-var EntryKindSchema = z2.enum(ENTRY_KINDS);
+var EntryKindSchema = z3.enum(ENTRY_KINDS);
 var BASIS_VALUES = ["stated", "decided", "inferred"];
-var BasisSchema = z2.enum(BASIS_VALUES);
-var Quote = z2.object({ messageId: z2.string().min(1), text: z2.string().min(1).max(500) });
+var BasisSchema = z3.enum(BASIS_VALUES);
+var Quote = z3.object({ messageId: z3.string().min(1), text: z3.string().min(1).max(500) });
 var DIAGRAM_TYPES = [
   "architecture",
   "workflow",
@@ -50,34 +87,34 @@ var DIAGRAM_TYPES = [
   "timeline",
   "waterfall"
 ];
-var DiagramMeta = z2.object({
-  repoId: z2.string().min(1),
-  type: z2.enum(DIAGRAM_TYPES),
+var DiagramMeta = z3.object({
+  repoId: z3.string().min(1),
+  type: z3.enum(DIAGRAM_TYPES),
   /** repo id -> main sha the diagram was drawn at. */
-  sourceCommits: z2.record(z2.string(), z2.string()),
+  sourceCommits: z3.record(z3.string(), z3.string()),
   /** archify node id -> repo-relative paths that node stands for. */
-  nodePaths: z2.record(z2.string(), z2.array(z2.string()))
+  nodePaths: z3.record(z3.string(), z3.array(z3.string()))
 });
 var MAX_WP_TASKS = 15;
-var WpTask = z2.object({
-  n: z2.number().int().min(1).max(MAX_WP_TASKS),
-  title: z2.string(),
-  satisfies: z2.array(z2.string()),
-  files: z2.array(z2.object({ op: z2.enum(["modify", "create"]), repo: z2.string(), path: z2.string() })),
-  status: z2.enum(["pending", "reported", "verified", "mismatch"]),
-  inferred: z2.boolean(),
-  reportMessageId: z2.string().nullable(),
-  confirmedBy: z2.literal("user").nullable()
+var WpTask = z3.object({
+  n: z3.number().int().min(1).max(MAX_WP_TASKS),
+  title: z3.string(),
+  satisfies: z3.array(z3.string()),
+  files: z3.array(z3.object({ op: z3.enum(["modify", "create"]), repo: z3.string(), path: z3.string() })),
+  status: z3.enum(["pending", "reported", "verified", "mismatch"]),
+  inferred: z3.boolean(),
+  reportMessageId: z3.string().nullable(),
+  confirmedBy: z3.literal("user").nullable()
 });
-var WorkPackageMeta = z2.object({
-  requirements: z2.array(z2.string()),
-  repos: z2.array(z2.string()),
-  approvedAt: z2.string().nullable(),
-  approvedCommit: z2.string().nullable(),
-  blockedOn: z2.string().nullable(),
-  tasks: z2.array(WpTask)
+var WorkPackageMeta = z3.object({
+  requirements: z3.array(z3.string()),
+  repos: z3.array(z3.string()),
+  approvedAt: z3.string().nullable(),
+  approvedCommit: z3.string().nullable(),
+  blockedOn: z3.string().nullable(),
+  tasks: z3.array(WpTask)
 });
-var IsoDateTime = z2.iso.datetime({ offset: true }).nullable();
+var IsoDateTime = z3.iso.datetime({ offset: true }).nullable();
 var PREFIX_KIND = {
   R: "requirement",
   D: "decision",
@@ -103,9 +140,9 @@ var KIND_STATUSES = {
   workpackage: ["draft", "approved", "in_progress", "done", "dropped"]
 };
 var ALL_STATUSES = ["active", "superseded", "dropped", "open", "resolved", "draft", "approved", "in_progress", "done"];
-var StatusSchema = z2.enum(ALL_STATUSES);
-var BusinessDate = z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable();
-var HttpUrl = z2.string().refine((s) => {
+var StatusSchema = z3.enum(ALL_STATUSES);
+var BusinessDate = z3.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable();
+var HttpUrl = z3.string().refine((s) => {
   try {
     const p = new URL(s).protocol;
     return p === "http:" || p === "https:";
@@ -113,17 +150,23 @@ var HttpUrl = z2.string().refine((s) => {
     return false;
   }
 }, "url must be http or https");
-var Priority = z2.union([z2.literal(1), z2.literal(2), z2.literal(3)]);
+var Priority = z3.union([z3.literal(1), z3.literal(2), z3.literal(3)]);
 function refineKind(v, ctx) {
   if (v.status !== void 0 && !KIND_STATUSES[v.kind].includes(v.status)) {
     ctx.addIssue({ code: "custom", path: ["status"], message: `invalid status "${v.status}" for ${v.kind}` });
   }
   if (v.kind === "source") {
-    if (v.url === void 0)
+    if (v.url === void 0 && v.sourceSnapshot === void 0)
       ctx.addIssue({ code: "custom", path: ["url"], message: "url is required for source" });
   } else if (v.url !== void 0) {
     ctx.addIssue({ code: "custom", path: ["url"], message: "url is only allowed for source" });
   }
+  if (v.sourceSnapshot !== void 0 && v.kind !== "source") {
+    ctx.addIssue({ code: "custom", path: ["sourceSnapshot"], message: "sourceSnapshot is only allowed for source" });
+  }
+  if (v.confirmedRevision != null && (v.kind !== "source" || v.sourceSnapshot === void 0)) {
+    ctx.addIssue({ code: "custom", path: ["confirmedRevision"], message: "confirmedRevision requires a source snapshot" });
+  }
   if (v.kind === "diagram") {
     if (v.diagram === void 0)
       ctx.addIssue({ code: "custom", path: ["diagram"], message: "diagram is required for diagram" });
@@ -146,14 +189,17 @@ function refineKind(v, ctx) {
     ctx.addIssue({ code: "custom", path: ["priority"], message: "priority is only allowed for question" });
   }
 }
-var EntryFrontmatter = z2.object({
-  id: z2.string().regex(ID_RE),
+var EntryFrontmatter = z3.object({
+  id: z3.string().regex(ID_RE),
   kind: EntryKindSchema,
-  title: z2.string().min(1).max(200),
+  title: z3.string().min(1).max(200),
   status: StatusSchema,
   businessDate: BusinessDate,
-  related: z2.array(z2.string()),
-  sourceMessages: z2.array(z2.string()),
+  related: z3.array(z3.string()),
+  sourceMessages: z3.array(z3.string()),
+  sourceSnapshot: SourceSnapshot.optional(),
+  sourceRefs: z3.array(SourceRef).max(10).default([]),
+  confirmedRevision: SourceRevision.default(null),
   url: HttpUrl.optional(),
   priority: Priority.optional(),
   diagram: DiagramMeta.optional(),
@@ -162,30 +208,31 @@ var EntryFrontmatter = z2.object({
   basis: BasisSchema.nullable(),
   ingestedAt: IsoDateTime,
   confirmedAt: IsoDateTime,
-  quotes: z2.array(Quote)
+  quotes: z3.array(Quote)
 }).superRefine((v, ctx) => {
   refineKind(v, ctx);
   if (kindFromId(v.id) !== v.kind) {
     ctx.addIssue({ code: "custom", path: ["id"], message: "id prefix does not match kind" });
   }
 });
-var UpsertEntryInput = z2.object({
-  id: z2.string().regex(ID_RE).optional(),
+var UpsertEntryInput = z3.object({
+  id: z3.string().regex(ID_RE).optional(),
   kind: EntryKindSchema,
-  title: z2.string().min(1).max(200),
-  body: z2.string(),
+  title: z3.string().min(1).max(200),
+  body: z3.string(),
   status: StatusSchema.optional(),
   businessDate: BusinessDate.optional(),
-  related: z2.array(z2.string()).optional(),
-  sourceMessages: z2.array(z2.string()).default([]),
+  related: z3.array(z3.string()).optional(),
+  sourceMessages: z3.array(z3.string()).default([]),
+  sourceRefs: z3.array(SourceRef).max(10).optional(),
   url: HttpUrl.optional(),
   priority: Priority.optional(),
   /** Requirements only. The Room API checks it against reports; omitted keeps the stored one. */
   implementation: Implementation.optional(),
   basis: BasisSchema.optional(),
-  quotes: z2.array(Quote).max(10).optional(),
-  confirmed: z2.boolean().optional(),
-  reason: z2.string().min(1).max(500)
+  quotes: z3.array(Quote).max(10).optional(),
+  confirmed: z3.boolean().optional(),
+  reason: z3.string().min(1).max(500)
 }).superRefine((v, ctx) => {
   refineKind(v, ctx);
   if (v.id !== void 0 && kindFromId(v.id) !== v.kind) {
@@ -194,23 +241,23 @@ var UpsertEntryInput = z2.object({
 });
 
 // ../../../packages/shared/dist/workspace.js
-import { z as z3 } from "zod";
-var MessageQuote = z3.object({
-  messageId: z3.string(),
-  role: z3.enum(["user", "agent", "system", "report"]),
-  excerpt: z3.string()
+import { z as z4 } from "zod";
+var MessageQuote = z4.object({
+  messageId: z4.string(),
+  role: z4.enum(["user", "agent", "system", "report"]),
+  excerpt: z4.string()
 });
-var UserMessageMeta = z3.object({
+var UserMessageMeta = z4.object({
   quote: MessageQuote.optional()
 });
-var AgentMessageMeta = z3.object({
-  changes: z3.array(z3.object({
-    entryId: z3.string(),
+var AgentMessageMeta = z4.object({
+  changes: z4.array(z4.object({
+    entryId: z4.string(),
     kind: EntryKindSchema,
-    title: z3.string(),
-    op: z3.enum(["add", "update"])
+    title: z4.string(),
+    op: z4.enum(["add", "update"])
   })),
-  askedQuestion: z3.object({ id: z3.string(), title: z3.string(), body: z3.string() }).nullable(),
+  askedQuestion: z4.object({ id: z4.string(), title: z4.string(), body: z4.string() }).nullable(),
   quote: MessageQuote.optional()
 });
 function isBranchName(name) {
@@ -627,48 +674,48 @@ function bundledExtensions() {
 }
 
 // ../../../packages/shared/dist/protocol.js
-import { z as z4 } from "zod";
-var DaemonToHubSchema = z4.union([
-  z4.object({
-    type: z4.literal("hello"),
-    token: z4.string(),
-    version: z4.string(),
-    adapters: z4.array(z4.string()),
+import { z as z5 } from "zod";
+var DaemonToHubSchema = z5.union([
+  z5.object({
+    type: z5.literal("hello"),
+    token: z5.string(),
+    version: z5.string(),
+    adapters: z5.array(z5.string()),
     /** sha256 hex of ~/.nema/report-token, sent when that file exists. */
-    reportTokenHash: z4.string().regex(/^[0-9a-f]{64}$/).optional()
+    reportTokenHash: z5.string().regex(/^[0-9a-f]{64}$/).optional()
   }),
-  z4.object({
-    type: z4.literal("task.event"),
-    taskId: z4.string(),
-    event: z4.object({ type: z4.enum(["progress", "agent_message", "tool_call"]), text: z4.string() })
+  z5.object({
+    type: z5.literal("task.event"),
+    taskId: z5.string(),
+    event: z5.object({ type: z5.enum(["progress", "agent_message", "tool_call"]), text: z5.string() })
   }),
-  z4.object({ type: z4.literal("task.finished"), taskId: z4.string(), ok: z4.literal(true), reply: z4.string() }),
-  z4.object({ type: z4.literal("task.finished"), taskId: z4.string(), ok: z4.literal(false), error: z4.string() }),
-  z4.object({ type: z4.literal("rpc.response"), id: z4.string(), ok: z4.literal(true), result: z4.unknown() }),
-  z4.object({ type: z4.literal("rpc.response"), id: z4.string(), ok: z4.literal(false), error: z4.string() }),
-  z4.object({ type: z4.literal("repo.moved"), repoId: z4.string(), mainRef: z4.string(), from: z4.string().nullable(), to: z4.string() }),
-  z4.object({ type: z4.literal("repo.fetched"), repoId: z4.string(), ok: z4.boolean(), error: z4.string().optional(), at: z4.string() })
+  z5.object({ type: z5.literal("task.finished"), taskId: z5.string(), ok: z5.literal(true), reply: z5.string() }),
+  z5.object({ type: z5.literal("task.finished"), taskId: z5.string(), ok: z5.literal(false), error: z5.string() }),
+  z5.object({ type: z5.literal("rpc.response"), id: z5.string(), ok: z5.literal(true), result: z5.unknown() }),
+  z5.object({ type: z5.literal("rpc.response"), id: z5.string(), ok: z5.literal(false), error: z5.string() }),
+  z5.object({ type: z5.literal("repo.moved"), repoId: z5.string(), mainRef: z5.string(), from: z5.string().nullable(), to: z5.string() }),
+  z5.object({ type: z5.literal("repo.fetched"), repoId: z5.string(), ok: z5.boolean(), error: z5.string().optional(), at: z5.string() })
 ]);
-var HubToDaemonSchema = z4.discriminatedUnion("type", [
+var HubToDaemonSchema = z5.discriminatedUnion("type", [
   // workspaceIds: every workspace that still exists, so the daemon can remove the isolation dirs
   // (`~/.nema/ws/<id>`) of workspaces deleted while it was offline. Optional for older hubs.
-  z4.object({ type: z4.literal("welcome"), workspaceIds: z4.array(z4.string()).optional() }),
+  z5.object({ type: z5.literal("welcome"), workspaceIds: z5.array(z5.string()).optional() }),
   // Sent to a connected daemon when a workspace is deleted, so it removes that workspace's isolation dir.
-  z4.object({ type: z4.literal("workspace.deleted"), workspaceId: z4.string() }),
-  z4.object({
-    type: z4.literal("task.assign"),
-    taskId: z4.string(),
-    workspaceId: z4.string(),
-    adapter: z4.string().min(1),
-    confidential: z4.boolean(),
-    prompt: z4.string(),
-    runToken: z4.string(),
-    hubUrl: z4.string(),
-    pluginTools: z4.array(z4.object({ name: z4.string(), description: z4.string(), parameters: z4.record(z4.string(), z4.unknown()) })),
-    limits: z4.object({ maxModelCalls: z4.number().int().min(1), maxToolCalls: z4.number().int().min(1), timeoutMs: z4.number().int().min(1) }).optional()
+  z5.object({ type: z5.literal("workspace.deleted"), workspaceId: z5.string() }),
+  z5.object({
+    type: z5.literal("task.assign"),
+    taskId: z5.string(),
+    workspaceId: z5.string(),
+    adapter: z5.string().min(1),
+    confidential: z5.boolean(),
+    prompt: z5.string(),
+    runToken: z5.string(),
+    hubUrl: z5.string(),
+    pluginTools: z5.array(z5.object({ name: z5.string(), description: z5.string(), parameters: z5.record(z5.string(), z5.unknown()) })),
+    limits: z5.object({ maxModelCalls: z5.number().int().min(1), maxToolCalls: z5.number().int().min(1), timeoutMs: z5.number().int().min(1) }).optional()
   }),
-  z4.object({ type: z4.literal("rpc.request"), id: z4.string(), method: z4.string(), params: z4.unknown() }),
-  z4.object({ type: z4.literal("error"), message: z4.string() })
+  z5.object({ type: z5.literal("rpc.request"), id: z5.string(), method: z5.string(), params: z5.unknown() }),
+  z5.object({ type: z5.literal("error"), message: z5.string() })
 ]);
 function parseHubToDaemon(raw) {
   return HubToDaemonSchema.parse(raw);

package/dist/daemon/connection.js

@@ -1,6 +1,6 @@
 import {
   parseHubToDaemon
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // daemon/connection.js
 import WebSocket from "ws";

package/dist/direct/tools.js

@@ -1,6 +1,6 @@
 import {
   UpsertEntryInput
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // direct/tools.js
 import { z } from "zod";

package/dist/extensions/store.js

@@ -1,6 +1,6 @@
 import {
   bundledExtensions
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // extensions/store.js
 import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";

package/dist/github/client.js

@@ -4,7 +4,7 @@ import {
 import {
   GH_COMMAND_TOOLS,
   PLUGINS
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // github/client.js
 import { execFile, spawn } from "node:child_process";

package/dist/github/gh.js

@@ -3,7 +3,7 @@ import {
 } from "../chunks/chunk-WT3XUFWU.js";
 import {
   parseGhCommand
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // github/gh.js
 import { commandSpec, windowsRuntimeEnv } from "../platform.js";

package/dist/report/commands.js

@@ -1,7 +1,7 @@
 import {
   HookSignal,
   ReportInput
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // report/commands.js
 import { repoInfo } from "./git.js";

package/dist/repos/git.js

@@ -3,7 +3,7 @@ import {
 } from "../chunks/chunk-WT3XUFWU.js";
 import {
   isBranchName
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // repos/git.js
 import { execFile } from "node:child_process";

package/dist/repos/handlers.js

@@ -1,6 +1,6 @@
 import {
   GH_COMMAND_TOOLS
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-XDIAG2QH.js";
 
 // repos/handlers.js
 import { lstat, rm, unlink } from "node:fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nema-project/nema",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "license": "MIT",
   "type": "module",
   "bin": {