hivehq 2.0.0

package/dist/src/server/team-memory-http-serializers.d.ts

@@ -0,0 +1,102 @@
+import type { MemoryEntryWithSources, MemoryInjectionWithMemory, MemorySearchResult } from './team-memory-store.js';
+export declare const serializeMemoryEntry: (entry: MemoryEntryWithSources) => {
+    archived_at: number | null;
+    body: string;
+    confidence: number | null;
+    created_at: number;
+    disabled: boolean;
+    id: string;
+    kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
+    last_injected_at: number | null;
+    pinned: boolean;
+    scope: "workspace" | "user";
+    source: import("./team-memory-store.js").MemorySource;
+    sources: {
+        actor_agent_id_snapshot: string | null;
+        actor_name_snapshot: string | null;
+        actor_role_snapshot: string | null;
+        created_at: number;
+        excerpt: string | null;
+        id: string;
+        memory_id: string;
+        source_id: string | null;
+        source_sequence: number | null;
+        source_type: import("./team-memory-store.js").MemorySourceType;
+        text_hash: string | null;
+    }[];
+    status: import("./team-memory-store.js").MemoryStatus;
+    tags: string[];
+    updated_at: number;
+    workspace_id: string | null;
+};
+export declare const serializeMemorySearchResult: (entry: MemorySearchResult) => {
+    index_name: "like" | "trigram" | "unicode";
+    score: number;
+    archived_at: number | null;
+    body: string;
+    confidence: number | null;
+    created_at: number;
+    disabled: boolean;
+    id: string;
+    kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
+    last_injected_at: number | null;
+    pinned: boolean;
+    scope: "workspace" | "user";
+    source: import("./team-memory-store.js").MemorySource;
+    sources: {
+        actor_agent_id_snapshot: string | null;
+        actor_name_snapshot: string | null;
+        actor_role_snapshot: string | null;
+        created_at: number;
+        excerpt: string | null;
+        id: string;
+        memory_id: string;
+        source_id: string | null;
+        source_sequence: number | null;
+        source_type: import("./team-memory-store.js").MemorySourceType;
+        text_hash: string | null;
+    }[];
+    status: import("./team-memory-store.js").MemoryStatus;
+    tags: string[];
+    updated_at: number;
+    workspace_id: string | null;
+};
+export declare const serializeMemoryInjection: (injection: MemoryInjectionWithMemory) => {
+    context_type: import("./team-memory-store.js").MemoryInjectionContext;
+    dispatch_id: string | null;
+    id: string;
+    injected_at: number;
+    memory: {
+        archived_at: number | null;
+        body: string;
+        confidence: number | null;
+        created_at: number;
+        disabled: boolean;
+        id: string;
+        kind: "fact" | "preference" | "decision" | "pitfall" | "procedure_ref";
+        last_injected_at: number | null;
+        pinned: boolean;
+        scope: "workspace" | "user";
+        source: import("./team-memory-store.js").MemorySource;
+        sources: {
+            actor_agent_id_snapshot: string | null;
+            actor_name_snapshot: string | null;
+            actor_role_snapshot: string | null;
+            created_at: number;
+            excerpt: string | null;
+            id: string;
+            memory_id: string;
+            source_id: string | null;
+            source_sequence: number | null;
+            source_type: import("./team-memory-store.js").MemorySourceType;
+            text_hash: string | null;
+        }[];
+        status: import("./team-memory-store.js").MemoryStatus;
+        tags: string[];
+        updated_at: number;
+        workspace_id: string | null;
+    };
+    memory_id: string;
+    target_agent_id_snapshot: string | null;
+    workspace_id: string | null;
+};

package/dist/src/server/team-memory-http-serializers.js

@@ -0,0 +1,46 @@
+const serializeMemorySource = (source) => ({
+    actor_agent_id_snapshot: source.actorAgentIdSnapshot,
+    actor_name_snapshot: source.actorNameSnapshot,
+    actor_role_snapshot: source.actorRoleSnapshot,
+    created_at: source.createdAt,
+    excerpt: source.excerpt,
+    id: source.id,
+    memory_id: source.memoryId,
+    source_id: source.sourceId,
+    source_sequence: source.sourceSequence,
+    source_type: source.sourceType,
+    text_hash: source.textHash,
+});
+export const serializeMemoryEntry = (entry) => ({
+    archived_at: entry.archivedAt,
+    body: entry.body,
+    confidence: entry.confidence,
+    created_at: entry.createdAt,
+    disabled: entry.disabled,
+    id: entry.id,
+    kind: entry.kind,
+    last_injected_at: entry.lastInjectedAt,
+    pinned: entry.pinned,
+    scope: entry.scope,
+    source: entry.source,
+    sources: entry.sources.map(serializeMemorySource),
+    status: entry.status,
+    tags: entry.tags,
+    updated_at: entry.updatedAt,
+    workspace_id: entry.workspaceId,
+});
+export const serializeMemorySearchResult = (entry) => ({
+    ...serializeMemoryEntry(entry),
+    index_name: entry.indexName,
+    score: entry.score,
+});
+export const serializeMemoryInjection = (injection) => ({
+    context_type: injection.contextType,
+    dispatch_id: injection.dispatchId,
+    id: injection.id,
+    injected_at: injection.injectedAt,
+    memory: serializeMemoryEntry(injection.memory),
+    memory_id: injection.memoryId,
+    target_agent_id_snapshot: injection.targetAgentIdSnapshot,
+    workspace_id: injection.workspaceId,
+});

package/dist/src/server/team-memory-injection.d.ts

@@ -0,0 +1,31 @@
+import type { MemoryDigestPayload, WorkspaceMemoryDigestProvider } from './team-memory-digest.js';
+import type { LogMemoryInjectionsInput } from './team-memory-store.js';
+export interface TeamMemoryInjectionService {
+    buildDigest: WorkspaceMemoryDigestProvider['buildDigest'];
+    buildDispatchDigest: WorkspaceMemoryDigestProvider['buildDispatchDigest'];
+    deleteInjections: (injectionIds: string[]) => void;
+    logInjections: (input: LogMemoryInjectionsInput) => string[];
+}
+export declare const buildMemoryDigestSafely: ({ contextType, memoryInjection, workspaceId, }: {
+    contextType: "recovery" | "startup";
+    memoryInjection: TeamMemoryInjectionService | undefined;
+    workspaceId: string;
+}) => MemoryDigestPayload | null;
+export declare const buildDispatchMemoryDigestSafely: ({ memoryInjection, taskText, workerDescription, workspaceId, }: {
+    memoryInjection: TeamMemoryInjectionService | undefined;
+    taskText: string;
+    workerDescription: string;
+    workspaceId: string;
+}) => MemoryDigestPayload | null;
+export declare const logMemoryDigestInjection: ({ agentId, contextType, dispatchId, memoryDigest, memoryInjection, workspaceId, }: {
+    agentId: string;
+    contextType: LogMemoryInjectionsInput["contextType"];
+    dispatchId?: string | null;
+    memoryDigest: MemoryDigestPayload | null | undefined;
+    memoryInjection: TeamMemoryInjectionService | undefined;
+    workspaceId: string;
+}) => string[] | null;
+export declare const rollbackMemoryDigestInjection: ({ injectionIds, memoryInjection, }: {
+    injectionIds: string[] | null;
+    memoryInjection: TeamMemoryInjectionService | undefined;
+}) => void;

package/dist/src/server/team-memory-injection.js

@@ -0,0 +1,49 @@
+export const buildMemoryDigestSafely = ({ contextType, memoryInjection, workspaceId, }) => {
+    if (!memoryInjection)
+        return null;
+    try {
+        return memoryInjection.buildDigest({ contextType, workspaceId });
+    }
+    catch (error) {
+        console.error('[hive] memory digest build failed', error);
+        return null;
+    }
+};
+export const buildDispatchMemoryDigestSafely = ({ memoryInjection, taskText, workerDescription, workspaceId, }) => {
+    if (!memoryInjection)
+        return null;
+    try {
+        return memoryInjection.buildDispatchDigest({ taskText, workerDescription, workspaceId });
+    }
+    catch (error) {
+        console.error('[hive] dispatch memory digest build failed', error);
+        return null;
+    }
+};
+export const logMemoryDigestInjection = ({ agentId, contextType, dispatchId, memoryDigest, memoryInjection, workspaceId, }) => {
+    if (!memoryDigest || memoryDigest.memoryIds.length === 0 || !memoryInjection)
+        return null;
+    try {
+        return memoryInjection.logInjections({
+            contextType,
+            dispatchId: dispatchId ?? null,
+            memoryIds: memoryDigest.memoryIds,
+            targetAgentIdSnapshot: agentId,
+            workspaceId,
+        });
+    }
+    catch (error) {
+        console.error('[hive] memory injection audit failed', error);
+        return null;
+    }
+};
+export const rollbackMemoryDigestInjection = ({ injectionIds, memoryInjection, }) => {
+    if (!injectionIds || injectionIds.length === 0 || !memoryInjection)
+        return;
+    try {
+        memoryInjection.deleteInjections(injectionIds);
+    }
+    catch (error) {
+        console.error('[hive] memory injection audit rollback failed', error);
+    }
+};

package/dist/src/server/team-memory-store.d.ts

@@ -0,0 +1,116 @@
+import type { Database } from 'better-sqlite3';
+import { type MemoryKind } from '../shared/team-memory.js';
+import type { AgentSummary } from '../shared/types.js';
+export type MemoryStatus = 'active' | 'candidate' | 'archived' | 'rejected';
+export type MemorySource = 'manual' | 'dream';
+export type MemorySourceType = 'manual' | 'message' | 'dispatch' | 'report' | 'dream';
+export type MemoryInjectionContext = 'startup' | 'dispatch' | 'recovery' | 'manual_search';
+export interface MemoryActorSnapshot {
+    id: string;
+    name: string;
+    role: AgentSummary['role'];
+}
+export interface MemoryEntryRecord {
+    archivedAt: number | null;
+    body: string;
+    confidence: number | null;
+    createdAt: number;
+    disabled: boolean;
+    id: string;
+    kind: MemoryKind;
+    lastInjectedAt: number | null;
+    pinned: boolean;
+    scope: 'workspace' | 'user';
+    source: MemorySource;
+    status: MemoryStatus;
+    tags: string[];
+    updatedAt: number;
+    workspaceId: string | null;
+}
+export interface MemorySourceRecord {
+    actorAgentIdSnapshot: string | null;
+    actorNameSnapshot: string | null;
+    actorRoleSnapshot: string | null;
+    createdAt: number;
+    excerpt: string | null;
+    id: string;
+    memoryId: string;
+    sourceId: string | null;
+    sourceSequence: number | null;
+    sourceType: MemorySourceType;
+    textHash: string | null;
+}
+export interface MemoryEntryWithSources extends MemoryEntryRecord {
+    sources: MemorySourceRecord[];
+}
+export interface MemorySearchResult extends MemoryEntryWithSources {
+    indexName: 'like' | 'trigram' | 'unicode';
+    score: number;
+}
+export interface AddMemoryEntryInput {
+    actor: MemoryActorSnapshot;
+    body: string;
+    confidence?: number | null;
+    kind: MemoryKind;
+    source?: MemorySource;
+    tags?: string[];
+    workspaceId: string;
+}
+export interface LogMemoryInjectionsInput {
+    contextType: MemoryInjectionContext;
+    dispatchId?: string | null;
+    memoryIds: string[];
+    targetAgentIdSnapshot?: string | null;
+    workspaceId: string;
+}
+export interface MemorySearchOptions {
+    includeDisabled?: boolean;
+    limit?: number;
+    statuses?: MemoryStatus[];
+}
+export interface MemoryListOptions {
+    limit?: number;
+    statuses?: MemoryStatus[];
+}
+export interface MemoryDigestOptions {
+    limit?: number;
+}
+export interface MemoryInjectionWithMemory {
+    contextType: MemoryInjectionContext;
+    dispatchId: string | null;
+    id: string;
+    injectedAt: number;
+    memory: MemoryEntryWithSources;
+    memoryId: string;
+    targetAgentIdSnapshot: string | null;
+    workspaceId: string | null;
+}
+export declare class MemoryEntryNotFoundError extends Error {
+    readonly memoryId: string;
+    readonly workspaceId: string;
+    constructor(memoryId: string, workspaceId: string);
+}
+export declare class MemoryEntryStatusError extends Error {
+    readonly actualStatus: MemoryStatus;
+    readonly memoryId: string;
+    readonly expectedStatus: MemoryStatus | MemoryStatus[];
+    constructor(memoryId: string, expectedStatus: MemoryStatus | MemoryStatus[], actualStatus: MemoryStatus);
+}
+export declare const createTeamMemoryStore: (db: Database) => {
+    addEntry: (input: AddMemoryEntryInput) => MemoryEntryWithSources;
+    approveCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    archiveEntry: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    deleteWorkspaceMemories: (workspaceId: string) => void;
+    deleteInjections: (injectionIds: string[]) => void;
+    getEntryWithSources: (workspaceId: string, memoryId: string) => MemoryEntryWithSources | undefined;
+    listDigestEntries: (workspaceId: string, options?: MemoryDigestOptions) => MemoryEntryWithSources[];
+    listExportEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    listAllEntries: (workspaceId: string) => MemoryEntryWithSources[];
+    listEntries: (workspaceId: string, options?: MemoryListOptions) => MemoryEntryWithSources[];
+    listInjectionsForDispatch: (workspaceId: string, dispatchId: string) => MemoryInjectionWithMemory[];
+    logInjections: (input: LogMemoryInjectionsInput) => `${string}-${string}-${string}-${string}-${string}`[];
+    rejectCandidate: (workspaceId: string, memoryId: string) => MemoryEntryWithSources;
+    searchEntries: (workspaceId: string, query: string, options?: MemorySearchOptions) => MemorySearchResult[];
+    setDisabled: (workspaceId: string, memoryId: string, disabled: boolean) => MemoryEntryWithSources;
+    setPinned: (workspaceId: string, memoryId: string, pinned: boolean) => MemoryEntryWithSources;
+};