@engram-cli/contracts 0.1.0

package/README.md

@@ -0,0 +1,12 @@
+# packages/contracts
+
+Shared **MemoryEvent** + **Capsule** zod schemas, list caps, markdown projector.
+
+Canonical field definitions and team API contract: [CONTEXT.md](../CONTEXT.md).
+
+```bash
+npm install
+npm run build
+```
+
+Consumed by `backend/` via `"@engram-cli/contracts": "file:../packages/contracts"`.

package/dist/caps.d.ts

@@ -0,0 +1,12 @@
+/** Capsule / ingest list and size caps (canonical). */
+export declare const CAPS: {
+    readonly recentFiles: 8;
+    readonly errors: 5;
+    readonly failedCommands: 5;
+    readonly manualNotes: 5;
+    readonly summaryBytes: 2048;
+    readonly stderrBytes: 2048;
+    readonly contentBytes: 2048;
+};
+export declare const CAPSULE_SCHEMA_VERSION = 1;
+//# sourceMappingURL=caps.d.ts.map

package/dist/caps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caps.d.ts","sourceRoot":"","sources":["../src/caps.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,eAAO,MAAM,IAAI;;;;;;;;CAQP,CAAC;AAEX,eAAO,MAAM,sBAAsB,IAAI,CAAC"}

package/dist/caps.js

@@ -0,0 +1,11 @@
+/** Capsule / ingest list and size caps (canonical). */
+export const CAPS = {
+    recentFiles: 8,
+    errors: 5,
+    failedCommands: 5,
+    manualNotes: 5,
+    summaryBytes: 2048,
+    stderrBytes: 2048,
+    contentBytes: 2048,
+};
+export const CAPSULE_SCHEMA_VERSION = 1;

package/dist/capsule.d.ts

@@ -0,0 +1,184 @@
+import { z } from "zod";
+export declare const CapsuleErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    file_path: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    file_path?: string | undefined;
+    line?: number | undefined;
+}, {
+    message: string;
+    file_path?: string | undefined;
+    line?: number | undefined;
+}>;
+export type CapsuleError = z.infer<typeof CapsuleErrorSchema>;
+export declare const CapsuleFailedCommandSchema: z.ZodObject<{
+    command: z.ZodString;
+    exit_code: z.ZodNumber;
+    stderr_tail: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    exit_code: number;
+    stderr_tail?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    command: string;
+    exit_code: number;
+    stderr_tail?: string | undefined;
+    cwd?: string | undefined;
+}>;
+export type CapsuleFailedCommand = z.infer<typeof CapsuleFailedCommandSchema>;
+export declare const CapsuleGitSchema: z.ZodObject<{
+    branch: z.ZodOptional<z.ZodString>;
+    last_commit: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    branch?: string | undefined;
+    last_commit?: string | undefined;
+}, {
+    branch?: string | undefined;
+    last_commit?: string | undefined;
+}>;
+export type CapsuleGit = z.infer<typeof CapsuleGitSchema>;
+export declare const CapsuleManualNoteSchema: z.ZodObject<{
+    kind: z.ZodEnum<["code_selection", "clipboard", "chat_summary"]>;
+    text: z.ZodString;
+    file_path: z.ZodOptional<z.ZodString>;
+    chat_label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kind: "code_selection" | "clipboard" | "chat_summary";
+    text: string;
+    file_path?: string | undefined;
+    chat_label?: string | undefined;
+}, {
+    kind: "code_selection" | "clipboard" | "chat_summary";
+    text: string;
+    file_path?: string | undefined;
+    chat_label?: string | undefined;
+}>;
+export type CapsuleManualNote = z.infer<typeof CapsuleManualNoteSchema>;
+export declare const CapsuleSchema: z.ZodObject<{
+    capsule_id: z.ZodString;
+    project: z.ZodString;
+    created_at: z.ZodString;
+    source_ide: z.ZodOptional<z.ZodString>;
+    schema_version: z.ZodDefault<z.ZodNumber>;
+    summary: z.ZodString;
+    recent_files: z.ZodArray<z.ZodString, "many">;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        file_path: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        file_path?: string | undefined;
+        line?: number | undefined;
+    }, {
+        message: string;
+        file_path?: string | undefined;
+        line?: number | undefined;
+    }>, "many">;
+    failed_commands: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exit_code: z.ZodNumber;
+        stderr_tail: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command: string;
+        exit_code: number;
+        stderr_tail?: string | undefined;
+        cwd?: string | undefined;
+    }, {
+        command: string;
+        exit_code: number;
+        stderr_tail?: string | undefined;
+        cwd?: string | undefined;
+    }>, "many">;
+    git: z.ZodObject<{
+        branch: z.ZodOptional<z.ZodString>;
+        last_commit: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        branch?: string | undefined;
+        last_commit?: string | undefined;
+    }, {
+        branch?: string | undefined;
+        last_commit?: string | undefined;
+    }>;
+    manual_notes: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<["code_selection", "clipboard", "chat_summary"]>;
+        text: z.ZodString;
+        file_path: z.ZodOptional<z.ZodString>;
+        chat_label: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "code_selection" | "clipboard" | "chat_summary";
+        text: string;
+        file_path?: string | undefined;
+        chat_label?: string | undefined;
+    }, {
+        kind: "code_selection" | "clipboard" | "chat_summary";
+        text: string;
+        file_path?: string | undefined;
+        chat_label?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    capsule_id: string;
+    project: string;
+    created_at: string;
+    schema_version: number;
+    summary: string;
+    recent_files: string[];
+    errors: {
+        message: string;
+        file_path?: string | undefined;
+        line?: number | undefined;
+    }[];
+    failed_commands: {
+        command: string;
+        exit_code: number;
+        stderr_tail?: string | undefined;
+        cwd?: string | undefined;
+    }[];
+    git: {
+        branch?: string | undefined;
+        last_commit?: string | undefined;
+    };
+    manual_notes: {
+        kind: "code_selection" | "clipboard" | "chat_summary";
+        text: string;
+        file_path?: string | undefined;
+        chat_label?: string | undefined;
+    }[];
+    source_ide?: string | undefined;
+}, {
+    capsule_id: string;
+    project: string;
+    created_at: string;
+    summary: string;
+    recent_files: string[];
+    errors: {
+        message: string;
+        file_path?: string | undefined;
+        line?: number | undefined;
+    }[];
+    failed_commands: {
+        command: string;
+        exit_code: number;
+        stderr_tail?: string | undefined;
+        cwd?: string | undefined;
+    }[];
+    git: {
+        branch?: string | undefined;
+        last_commit?: string | undefined;
+    };
+    manual_notes: {
+        kind: "code_selection" | "clipboard" | "chat_summary";
+        text: string;
+        file_path?: string | undefined;
+        chat_label?: string | undefined;
+    }[];
+    source_ide?: string | undefined;
+    schema_version?: number | undefined;
+}>;
+export type Capsule = z.infer<typeof CapsuleSchema>;
+//# sourceMappingURL=capsule.d.ts.map

package/dist/capsule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capsule.d.ts","sourceRoot":"","sources":["../src/capsule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAKrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,gBAAgB;;;;;;;;;EAG3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAKlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYxB,CAAC;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/capsule.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { CAPSULE_SCHEMA_VERSION } from "./caps.js";
+export const CapsuleErrorSchema = z.object({
+    message: z.string(),
+    file_path: z.string().optional(),
+    line: z.number().int().nonnegative().optional(),
+});
+export const CapsuleFailedCommandSchema = z.object({
+    command: z.string(),
+    exit_code: z.number().int(),
+    stderr_tail: z.string().optional(),
+    cwd: z.string().optional(),
+});
+export const CapsuleGitSchema = z.object({
+    branch: z.string().optional(),
+    last_commit: z.string().optional(),
+});
+export const CapsuleManualNoteSchema = z.object({
+    kind: z.enum(["code_selection", "clipboard", "chat_summary"]),
+    text: z.string(),
+    file_path: z.string().optional(),
+    chat_label: z.string().optional(),
+});
+export const CapsuleSchema = z.object({
+    capsule_id: z.string().min(1),
+    project: z.string().min(1),
+    created_at: z.string().min(1),
+    source_ide: z.string().optional(),
+    schema_version: z.number().int().default(CAPSULE_SCHEMA_VERSION),
+    summary: z.string(),
+    recent_files: z.array(z.string()),
+    errors: z.array(CapsuleErrorSchema),
+    failed_commands: z.array(CapsuleFailedCommandSchema),
+    git: CapsuleGitSchema,
+    manual_notes: z.array(CapsuleManualNoteSchema),
+});

package/dist/helpers.d.ts

@@ -0,0 +1,17 @@
+import type { MemoryEvent } from "./memory-event.js";
+/** Project slug → Supermemory containerTag. */
+export declare function projectContainerTag(slug: string): string;
+/** Project name/folder → Engram project slug (strips the `project_` prefix). */
+export declare function normalizeProjectSlug(name: string): string;
+/**
+ * Successful shell commands worth capturing even when exit code is 0.
+ * Kept in contracts so the terminal hook and CLI stay in sync.
+ */
+export declare const SIGNAL_COMMAND_PATTERNS: RegExp[];
+/** True if a successful command is a signal command worth capturing. */
+export declare function isSignalCommand(command: string): boolean;
+/** Truncate a string to at most `maxBytes` UTF-8 bytes. */
+export declare function truncateBytes(text: string, maxBytes: number): string;
+/** Deterministic fact string stored as Supermemory document content. */
+export declare function deterministicFactString(event: MemoryEvent): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,+CAA+C;AAC/C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQxD;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,EAU3C,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGxD;AAMD,2DAA2D;AAC3D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,wEAAwE;AACxE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAkClE"}

package/dist/helpers.js

@@ -0,0 +1,84 @@
+import { CAPS } from "./caps.js";
+/** Project slug → Supermemory containerTag. */
+export function projectContainerTag(slug) {
+    const normalized = slug
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 80);
+    return `project_${normalized || "unknown"}`;
+}
+/** Project name/folder → Engram project slug (strips the `project_` prefix). */
+export function normalizeProjectSlug(name) {
+    return projectContainerTag(name).replace(/^project_/, "") || "unknown";
+}
+/**
+ * Successful shell commands worth capturing even when exit code is 0.
+ * Kept in contracts so the terminal hook and CLI stay in sync.
+ */
+export const SIGNAL_COMMAND_PATTERNS = [
+    /^npm\s+(?:test|run\s+(?:test|build|deploy|check|lint|typecheck))/i,
+    /^pnpm\s+(?:test|run\s+(?:test|build|deploy|check|lint|typecheck))/i,
+    /^yarn\s+(?:test|run\s+(?:test|build|deploy|check|lint|typecheck))/i,
+    /^make\b/i,
+    /^cargo\s+(?:build|test|check|run)\b/i,
+    /^go\s+(?:build|test|run)\b/i,
+    /^docker\s+(?:build|compose\s+build|push)\b/i,
+    /^(?:pytest|vitest|jest|mocha|ava|tap)\b/i,
+    /^\.\/build\.sh\b/i,
+];
+/** True if a successful command is a signal command worth capturing. */
+export function isSignalCommand(command) {
+    const firstLine = command.split("\n")[0]?.trim() ?? command;
+    return SIGNAL_COMMAND_PATTERNS.some((re) => re.test(firstLine));
+}
+function utf8ByteLength(text) {
+    return new TextEncoder().encode(text).length;
+}
+/** Truncate a string to at most `maxBytes` UTF-8 bytes. */
+export function truncateBytes(text, maxBytes) {
+    if (utf8ByteLength(text) <= maxBytes)
+        return text;
+    let end = Math.min(text.length, maxBytes);
+    while (end > 0 && utf8ByteLength(text.slice(0, end)) > maxBytes) {
+        end -= 1;
+    }
+    return `${text.slice(0, end)}…`;
+}
+/** Deterministic fact string stored as Supermemory document content. */
+export function deterministicFactString(event) {
+    const raw = (() => {
+        switch (event.event_type) {
+            case "file_open":
+                return `opened: ${event.file_path ?? event.content}`;
+            case "file_save":
+                return `saved: ${event.file_path ?? event.content}`;
+            case "error": {
+                const loc = event.file_path
+                    ? `${event.file_path}${event.line != null ? `:${event.line}` : ""}`
+                    : undefined;
+                return loc ? `error: ${event.content} in ${loc}` : `error: ${event.content}`;
+            }
+            case "command": {
+                const code = event.exit_code ?? 0;
+                return `cmd (exit ${code}): ${event.content}`;
+            }
+            case "branch_switch":
+                return `branch: ${event.content}`;
+            case "commit":
+                return `commit: ${event.content}`;
+            case "code_selection":
+                return `selection: ${event.content}`;
+            case "clipboard":
+                return `clipboard: ${event.content}`;
+            case "chat_summary": {
+                const label = event.chat_label ? `[${event.chat_label}]` : "";
+                return `chat_summary${label}: ${event.content}`;
+            }
+            default:
+                return event.content;
+        }
+    })();
+    return truncateBytes(raw, CAPS.contentBytes);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { CAPS, CAPSULE_SCHEMA_VERSION } from "./caps.js";
+export { MemorySourceSchema, MemoryEventTypeSchema, MemoryEventSchema, type MemorySource, type MemoryEventType, type MemoryEvent, } from "./memory-event.js";
+export { CapsuleErrorSchema, CapsuleFailedCommandSchema, CapsuleGitSchema, CapsuleManualNoteSchema, CapsuleSchema, type CapsuleError, type CapsuleFailedCommand, type CapsuleGit, type CapsuleManualNote, type Capsule, } from "./capsule.js";
+export { projectContainerTag, normalizeProjectSlug, truncateBytes, deterministicFactString, isSignalCommand, SIGNAL_COMMAND_PATTERNS, } from "./helpers.js";
+export { toMarkdown } from "./markdown.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,iBAAiB,EACjB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,kBAAkB,EAClB,0BAA0B,EAC1B,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,OAAO,GACb,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,eAAe,EACf,uBAAuB,GACxB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { CAPS, CAPSULE_SCHEMA_VERSION } from "./caps.js";
+export { MemorySourceSchema, MemoryEventTypeSchema, MemoryEventSchema, } from "./memory-event.js";
+export { CapsuleErrorSchema, CapsuleFailedCommandSchema, CapsuleGitSchema, CapsuleManualNoteSchema, CapsuleSchema, } from "./capsule.js";
+export { projectContainerTag, normalizeProjectSlug, truncateBytes, deterministicFactString, isSignalCommand, SIGNAL_COMMAND_PATTERNS, } from "./helpers.js";
+export { toMarkdown } from "./markdown.js";

package/dist/markdown.d.ts

@@ -0,0 +1,4 @@
+import type { Capsule } from "./capsule.js";
+/** Project Markdown projection of a capsule (ENGRAM_CONTEXT.md). */
+export declare function toMarkdown(capsule: Capsule): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAwDnD"}

package/dist/markdown.js

@@ -0,0 +1,57 @@
+/** Project Markdown projection of a capsule (ENGRAM_CONTEXT.md). */
+export function toMarkdown(capsule) {
+    const lines = [
+        `# Engram Context — ${capsule.project}`,
+        "",
+        `capsule_id: ${capsule.capsule_id}`,
+        `created_at: ${capsule.created_at}`,
+        `schema_version: ${capsule.schema_version}`,
+    ];
+    if (capsule.source_ide)
+        lines.push(`source_ide: ${capsule.source_ide}`);
+    lines.push("", "## Summary", "", capsule.summary || "(empty)", "");
+    if (capsule.recent_files.length) {
+        lines.push("## Recent files", "");
+        for (const f of capsule.recent_files)
+            lines.push(`- ${f}`);
+        lines.push("");
+    }
+    if (capsule.errors.length) {
+        lines.push("## Errors", "");
+        for (const e of capsule.errors) {
+            const loc = e.file_path
+                ? `${e.file_path}${e.line != null ? `:${e.line}` : ""}`
+                : "";
+            lines.push(`- ${loc ? `${loc} — ` : ""}${e.message}`);
+        }
+        lines.push("");
+    }
+    if (capsule.failed_commands.length) {
+        lines.push("## Failed commands", "");
+        for (const c of capsule.failed_commands) {
+            lines.push(`- \`${c.command}\` (exit ${c.exit_code})`);
+            if (c.stderr_tail)
+                lines.push(`  stderr: ${c.stderr_tail}`);
+        }
+        lines.push("");
+    }
+    if (capsule.git.branch || capsule.git.last_commit) {
+        lines.push("## Git", "");
+        if (capsule.git.branch)
+            lines.push(`- branch: ${capsule.git.branch}`);
+        if (capsule.git.last_commit)
+            lines.push(`- last_commit: ${capsule.git.last_commit}`);
+        lines.push("");
+    }
+    if (capsule.manual_notes.length) {
+        lines.push("## Manual notes", "");
+        for (const n of capsule.manual_notes) {
+            const prefix = n.chat_label
+                ? `[${n.kind}:${n.chat_label}]`
+                : `[${n.kind}]`;
+            lines.push(`- ${prefix} ${n.text}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/memory-event.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const MemorySourceSchema: z.ZodEnum<["vscode", "terminal", "git", "manual"]>;
+export type MemorySource = z.infer<typeof MemorySourceSchema>;
+export declare const MemoryEventTypeSchema: z.ZodEnum<["file_open", "code_selection", "error", "file_save", "command", "branch_switch", "commit", "clipboard", "chat_summary"]>;
+export type MemoryEventType = z.infer<typeof MemoryEventTypeSchema>;
+export declare const MemoryEventSchema: z.ZodObject<{
+    source: z.ZodEnum<["vscode", "terminal", "git", "manual"]>;
+    event_type: z.ZodEnum<["file_open", "code_selection", "error", "file_save", "command", "branch_switch", "commit", "clipboard", "chat_summary"]>;
+    content: z.ZodString;
+    project: z.ZodString;
+    timestamp: z.ZodString;
+    session_id: z.ZodString;
+    file_path: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    exit_code: z.ZodOptional<z.ZodNumber>;
+    ide: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    chat_label: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    source: "git" | "vscode" | "terminal" | "manual";
+    event_type: "command" | "code_selection" | "clipboard" | "chat_summary" | "file_open" | "error" | "file_save" | "branch_switch" | "commit";
+    content: string;
+    timestamp: string;
+    session_id: string;
+    file_path?: string | undefined;
+    line?: number | undefined;
+    exit_code?: number | undefined;
+    cwd?: string | undefined;
+    chat_label?: string | undefined;
+    ide?: string | undefined;
+}, {
+    project: string;
+    source: "git" | "vscode" | "terminal" | "manual";
+    event_type: "command" | "code_selection" | "clipboard" | "chat_summary" | "file_open" | "error" | "file_save" | "branch_switch" | "commit";
+    content: string;
+    timestamp: string;
+    session_id: string;
+    file_path?: string | undefined;
+    line?: number | undefined;
+    exit_code?: number | undefined;
+    cwd?: string | undefined;
+    chat_label?: string | undefined;
+    ide?: string | undefined;
+}>;
+export type MemoryEvent = z.infer<typeof MemoryEventSchema>;
+//# sourceMappingURL=memory-event.d.ts.map

package/dist/memory-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-event.d.ts","sourceRoot":"","sources":["../src/memory-event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB,oDAAkD,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,qBAAqB,qIAUhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/memory-event.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export const MemorySourceSchema = z.enum(["vscode", "terminal", "git", "manual"]);
+export const MemoryEventTypeSchema = z.enum([
+    "file_open",
+    "code_selection",
+    "error",
+    "file_save",
+    "command",
+    "branch_switch",
+    "commit",
+    "clipboard",
+    "chat_summary",
+]);
+export const MemoryEventSchema = z.object({
+    source: MemorySourceSchema,
+    event_type: MemoryEventTypeSchema,
+    content: z.string().min(1),
+    project: z.string().min(1),
+    timestamp: z.string().min(1),
+    session_id: z.string().min(1),
+    file_path: z.string().optional(),
+    cwd: z.string().optional(),
+    exit_code: z.number().int().optional(),
+    ide: z.string().optional(),
+    line: z.number().int().nonnegative().optional(),
+    chat_label: z.string().optional(),
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@engram-cli/contracts",
+  "version": "0.1.0",
+  "description": "Shared schemas and helpers for Engram",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "engram",
+    "contracts",
+    "zod"
+  ]
+}