@pikku/mongodb 0.12.21 → 0.12.23

package/run-tests.sh

@@ -34,20 +34,35 @@ files=($(find src -type f -name "*.test.ts"))
 # Check if any files matched the pattern
 if [ ${#files[@]} -eq 0 ]; then
   echo "No test files found matching pattern: $pattern"
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ]; then
+    exit 1
+  fi
   exit 0
 fi
 
-# Construct the node command
-node_cmd=(node --import tsx --test)
+# Construct the bun command
+#
+# --parallel gives every test file its own worker process, which is what node's
+# `--test` did. Several suites keep module-level caches (a TypeScript program, a
+# temp fixture directory) that a shared process would leak between files.
+#
+# --timeout because bun caps a test at 5s by default where node had no cap, and
+# the suites that build real TypeScript programs run well past that.
+bun_cmd=(bun test --parallel --timeout 120000)
 
 # Append options based on flags
 if [ "$watch_mode" = true ]; then
-  node_cmd+=(--watch)
+  # --watch reruns in one process; parallel workers have nothing to watch.
+  bun_cmd=(bun test --watch --timeout 120000)
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
+  # --coverage-dir=. keeps lcov.info at the package root: CI merges every
+  # package's report by prefixing its SF paths with the file's own directory,
+  # so a nested coverage/ directory would re-root them one level too deep.
+  bun_cmd+=(--coverage --coverage-reporter=lcov --coverage-reporter=text --coverage-dir=.)
+  export PIKKU_TEST_COVERAGE=1
 fi
 
-# Execute the node command with the expanded list of files
-"${node_cmd[@]}" "${files[@]}"
+# Execute the bun command with the expanded list of files
+"${bun_cmd[@]}" "${files[@]}"

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/index.ts","../src/mongodb-agent-run-service.ts","../src/mongodb-agent-storage-service.ts","../src/mongodb-channel-store.ts","../src/mongodb-deployment-service.ts","../src/mongodb-eventhub-store.ts","../src/mongodb-secret-service.ts","../src/mongodb-session-store.ts","../src/mongodb-workflow-run-service.ts","../src/mongodb-workflow-service.ts","../src/pikku-mongodb.ts"],"version":"6.0.3"}

package/src/index.ts

@@ -1,14 +0,0 @@
-export { PikkuMongoDB } from './pikku-mongodb.js'
-
-export { MongoDBChannelStore } from './mongodb-channel-store.js'
-export { MongoDBEventHubStore } from './mongodb-eventhub-store.js'
-export { MongoDBWorkflowService } from './mongodb-workflow-service.js'
-export { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'
-export { MongoDBDeploymentService } from './mongodb-deployment-service.js'
-export { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js'
-export { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
-export { MongoDBSecretService } from './mongodb-secret-service.js'
-
-export type { WorkflowRunService } from '@pikku/core/workflow'
-export type { AgentRunService, AgentRunRow } from '@pikku/core/agent'
-export { MongoDBSessionStore } from './mongodb-session-store.js'

package/src/mongodb-agent-run-service.ts

@@ -1,234 +0,0 @@
-import type {
-  AgentThread,
-  AgentMessage,
-  AgentRunRow,
-  AgentRunService,
-} from '@pikku/core/agent'
-import type { Db, Collection } from 'mongodb'
-
-// Owner ids are untrusted input to the regex, so metacharacters must not be
-// able to widen the prefix match.
-const escapeRegExp = (value: string) =>
-  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-interface AgentThreadDoc {
-  _id: string
-  resourceId: string
-  title: string | null
-  metadata: any | null
-  createdAt: Date
-  updatedAt: Date
-}
-
-interface AgentMessageDoc {
-  _id: string
-  threadId: string
-  role: string
-  content: string | null
-  createdAt: Date
-}
-
-interface AgentToolCallDoc {
-  _id: string
-  threadId: string
-  messageId: string
-  runId: string | null
-  toolName: string
-  args: any
-  result: string | null
-  approvalStatus: string | null
-  approvalType: string | null
-  agentRunId: string | null
-  displayToolName: string | null
-  displayArgs: any | null
-  createdAt: Date
-}
-
-interface AgentRunDoc {
-  _id: string
-  agentName: string
-  threadId: string
-  resourceId: string
-  status: string
-  errorMessage: string | null
-  suspendReason: string | null
-  missingRpcs: any | null
-  usageInputTokens: number
-  usageOutputTokens: number
-  usageModel: string
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class MongoDBAgentRunService implements AgentRunService {
-  private threads: Collection<AgentThreadDoc>
-  private messages: Collection<AgentMessageDoc>
-  private toolCalls: Collection<AgentToolCallDoc>
-  private runs: Collection<AgentRunDoc>
-
-  constructor(db: Db) {
-    this.threads = db.collection<AgentThreadDoc>('agent_threads')
-    this.messages = db.collection<AgentMessageDoc>('agent_message')
-    this.toolCalls = db.collection<AgentToolCallDoc>('agent_tool_call')
-    this.runs = db.collection<AgentRunDoc>('agent_run')
-  }
-
-  async listThreads(options?: {
-    agentName?: string
-    resourceId?: string
-    owners?: string[]
-    limit?: number
-    offset?: number
-  }): Promise<AgentThread[]> {
-    const {
-      agentName,
-      resourceId,
-      owners,
-      limit = 50,
-      offset = 0,
-    } = options ?? {}
-
-    // An owners constraint is an authorization boundary, so an empty list must
-    // match nothing rather than degrade to "no filter".
-    if (owners && owners.length === 0) return []
-
-    let filter: Record<string, any> = {}
-
-    if (resourceId) {
-      filter.resourceId = resourceId
-    }
-
-    if (owners) {
-      filter.$or = owners.flatMap((owner) => [
-        { resourceId: owner },
-        { resourceId: { $regex: `^${escapeRegExp(owner)}:` } },
-      ])
-    }
-
-    if (agentName) {
-      const threadIds = await this.runs.distinct('threadId', {
-        agentName,
-      })
-      filter._id = { $in: threadIds }
-    }
-
-    const result = await this.threads
-      .find(filter)
-      .sort({ updatedAt: -1 })
-      .skip(offset)
-      .limit(limit)
-      .toArray()
-
-    return result.map((row) => this.mapThreadRow(row))
-  }
-
-  async getThread(threadId: string): Promise<AgentThread | null> {
-    const row = await this.threads.findOne({ _id: threadId })
-    if (!row) return null
-    return this.mapThreadRow(row)
-  }
-
-  async getThreadMessages(threadId: string): Promise<AgentMessage[]> {
-    const [msgResult, tcResult] = await Promise.all([
-      this.messages.find({ threadId }).sort({ createdAt: 1 }).toArray(),
-      this.toolCalls.find({ threadId }).sort({ createdAt: 1 }).toArray(),
-    ])
-
-    const tcByMessage = new Map<string, (typeof tcResult)[number][]>()
-    for (const tc of tcResult) {
-      const msgId = tc.messageId
-      if (!tcByMessage.has(msgId)) tcByMessage.set(msgId, [])
-      tcByMessage.get(msgId)!.push(tc)
-    }
-
-    const messages: AgentMessage[] = []
-    for (const row of msgResult) {
-      const msg: AgentMessage = {
-        id: row._id,
-        role: row.role as AgentMessage['role'],
-        content: row.content ?? undefined,
-        createdAt: new Date(row.createdAt),
-      }
-
-      const tcs = tcByMessage.get(msg.id)
-      if (tcs?.length) {
-        msg.toolCalls = tcs.map((tc) => ({
-          id: tc._id,
-          name: tc.toolName,
-          args: tc.args as Record<string, unknown>,
-        }))
-
-        const completed = tcs.filter((tc) => tc.result != null)
-        if (completed.length) {
-          messages.push(msg)
-          messages.push({
-            id: `tool-results-${msg.id}`,
-            role: 'tool',
-            toolResults: completed.map((tc) => ({
-              id: tc._id,
-              name: tc.toolName,
-              result: tc.result!,
-            })),
-            createdAt: msg.createdAt,
-          })
-          continue
-        }
-      }
-
-      messages.push(msg)
-    }
-
-    return messages
-  }
-
-  async getThreadRuns(threadId: string): Promise<AgentRunRow[]> {
-    const result = await this.runs
-      .find({ threadId })
-      .sort({ createdAt: -1 })
-      .toArray()
-
-    return result.map((row) => this.mapRunRow(row))
-  }
-
-  async deleteThread(threadId: string): Promise<boolean> {
-    await this.toolCalls.deleteMany({ threadId })
-    await this.messages.deleteMany({ threadId })
-    await this.runs.deleteMany({ threadId })
-    const result = await this.threads.deleteOne({ _id: threadId })
-    return result.deletedCount > 0
-  }
-
-  async getDistinctAgentNames(): Promise<string[]> {
-    const result = await this.runs.distinct('agentName')
-    return result.sort()
-  }
-
-  private mapThreadRow(row: AgentThreadDoc): AgentThread {
-    return {
-      id: row._id,
-      resourceId: row.resourceId,
-      title: row.title ?? undefined,
-      metadata: row.metadata ?? undefined,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-    }
-  }
-
-  private mapRunRow(row: AgentRunDoc): AgentRunRow {
-    return {
-      runId: row._id,
-      agentName: row.agentName,
-      threadId: row.threadId,
-      resourceId: row.resourceId,
-      status: row.status,
-      errorMessage: row.errorMessage ?? undefined,
-      suspendReason: row.suspendReason ?? undefined,
-      missingRpcs: row.missingRpcs ?? undefined,
-      usageInputTokens: Number(row.usageInputTokens),
-      usageOutputTokens: Number(row.usageOutputTokens),
-      usageModel: row.usageModel,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-    }
-  }
-}