@pikku/core 0.11.2 → 0.12.0

package/src/middleware-runner.test.ts

@@ -189,6 +189,128 @@ describe('combineMiddleware', () => {
     assert.equal(result[1], middleware2)
   })
 
+  test('should apply parent tag middleware to namespaced tag', () => {
+    const billingMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('billing', [billingMiddleware])
+
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [{ type: 'tag', tag: 'billing:read' }],
+    })
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0], billingMiddleware)
+  })
+
+  test('should apply exact tag middleware for non-namespaced tag', () => {
+    const billingMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('billing', [billingMiddleware])
+
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [{ type: 'tag', tag: 'billing' }],
+    })
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0], billingMiddleware)
+  })
+
+  test('should apply both exact and parent tag middleware (specific first)', () => {
+    const billingMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+    const billingReadMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('billing', [billingMiddleware])
+    addMiddleware('billing:read', [billingReadMiddleware])
+
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [{ type: 'tag', tag: 'billing:read' }],
+    })
+
+    assert.equal(result.length, 2)
+    assert.equal(result[0], billingReadMiddleware)
+    assert.equal(result[1], billingMiddleware)
+  })
+
+  test('should resolve multi-level namespace tags', () => {
+    const billingMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+    const billingReadMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+    const billingReadAdminMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('billing', [billingMiddleware])
+    addMiddleware('billing:read', [billingReadMiddleware])
+    addMiddleware('billing:read:admin', [billingReadAdminMiddleware])
+
+    const result = combineMiddleware('http', Math.random().toString(), {
+      wireInheritedMiddleware: [{ type: 'tag', tag: 'billing:read:admin' }],
+    })
+
+    assert.equal(result.length, 3)
+    assert.equal(result[0], billingReadAdminMiddleware)
+    assert.equal(result[1], billingReadMiddleware)
+    assert.equal(result[2], billingMiddleware)
+  })
+
+  test('should apply parent tag middleware via funcInheritedMiddleware', () => {
+    const billingMiddleware: CorePikkuMiddleware = async (
+      services,
+      wire,
+      next
+    ) => {
+      await next()
+    }
+
+    addMiddleware('billing', [billingMiddleware])
+
+    const result = combineMiddleware('http', Math.random().toString(), {
+      funcInheritedMiddleware: [{ type: 'tag', tag: 'billing:write' }],
+    })
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0], billingMiddleware)
+  })
+
   test('should ignore non-existent tags', () => {
     const middleware: CorePikkuMiddleware = async (services, wire, next) => {
       await next()

package/src/middleware-runner.ts

@@ -7,7 +7,7 @@ import {
   MiddlewareMetadata,
 } from './types/core.types.js'
 import { pikkuState } from './pikku-state.js'
-import { freezeDedupe } from './utils.js'
+import { freezeDedupe, getTagGroups } from './utils.js'
 
 /**
  * Runs a chain of middleware functions in sequence before executing the main function.
@@ -96,7 +96,7 @@ export const addMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
  * This function looks up middleware that was registered with registerMiddleware.
  * It's used internally by the framework to resolve middleware references in metadata.
  *
- * @param {string} name - The unique name (pikkuFuncName) of the middleware function.
+ * @param {string} name - The unique name (pikkuFuncId) of the middleware function.
  * @returns {CorePikkuMiddleware | undefined} The middleware function, or undefined if not found.
  *
  * @internal
@@ -116,7 +116,9 @@ const middlewareCache: Record<
   channel: {},
   queue: {},
   scheduler: {},
+  trigger: {},
   mcp: {},
+  agent: {},
   cli: {},
   workflow: {},
 }
@@ -179,12 +181,11 @@ export const combineMiddleware = (
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       } else if (meta.type === 'tag') {
-        // Look up tag middleware group from pikkuState
-        const group = pikkuState(packageName, 'middleware', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'middleware', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
-          // At runtime, all factories should be resolved to middleware
+        )
+        for (const group of groups) {
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       } else if (meta.type === 'wire') {
@@ -206,12 +207,11 @@ export const combineMiddleware = (
   if (funcInheritedMiddleware) {
     for (const meta of funcInheritedMiddleware) {
       if (meta.type === 'tag') {
-        // Look up tag middleware group from pikkuState
-        const group = pikkuState(packageName, 'middleware', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'middleware', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
-          // At runtime, all factories should be resolved to middleware
+        )
+        for (const group of groups) {
           resolved.push(...(group as CorePikkuMiddleware[]))
         }
       }

package/src/permissions.test.ts

@@ -82,6 +82,85 @@ describe('addPermission', () => {
     assert.equal(permissions[0], mockPermissionGroup)
   })
 
+  test('should apply parent tag permission to namespaced tag via runPermissions', async () => {
+    const billingPermission = async () => true
+
+    addPermission('billing', [billingPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      wireInheritedPermissions: [{ type: 'tag', tag: 'billing:write' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+  })
+
+  test('should apply both parent and exact tag permissions', async () => {
+    const executionOrder: string[] = []
+    const billingPermission = async () => {
+      executionOrder.push('billing')
+      return true
+    }
+    const billingReadPermission = async () => {
+      executionOrder.push('billing:read')
+      return true
+    }
+
+    addPermission('billing', [billingPermission])
+    addPermission('billing:read', [billingReadPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      wireInheritedPermissions: [{ type: 'tag', tag: 'billing:read' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+
+    assert.deepEqual(executionOrder, ['billing:read'])
+  })
+
+  test('should resolve multi-level namespace permissions', async () => {
+    const executionOrder: string[] = []
+    const billingPermission = async () => {
+      executionOrder.push('billing')
+      return false
+    }
+    const billingReadPermission = async () => {
+      executionOrder.push('billing:read')
+      return false
+    }
+    const billingReadAdminPermission = async () => {
+      executionOrder.push('billing:read:admin')
+      return true
+    }
+
+    addPermission('billing', [billingPermission])
+    addPermission('billing:read', [billingReadPermission])
+    addPermission('billing:read:admin', [billingReadAdminPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      wireInheritedPermissions: [{ type: 'tag', tag: 'billing:read:admin' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+
+    assert.deepEqual(executionOrder, ['billing:read:admin'])
+  })
+
+  test('should apply parent tag permission via funcInheritedPermissions', async () => {
+    const billingPermission = async () => true
+
+    addPermission('billing', [billingPermission])
+
+    await runPermissions('rpc', Math.random().toString(), {
+      funcInheritedPermissions: [{ type: 'tag', tag: 'billing:delete' }],
+      services: mockServices,
+      wire: {},
+      data: {},
+    })
+  })
+
   test('should throw error when tag already exists', () => {
     const mockPermission = async () => true
 
@@ -171,13 +250,8 @@ describe('runPermissions', () => {
       data: {},
     })
 
-    // Order: wireInheritedPermissions (wiringTag) → wirePermissions → funcInheritedPermissions (funcTag) → funcPermissions
-    assert.deepEqual(executionOrder, [
-      'wiringTag',
-      'wiringPermission',
-      'funcTag',
-      'funcPermission',
-    ])
+    // Order: wireInheritedPermissions (wiringTag) only (short-circuit on first passing group)
+    assert.deepEqual(executionOrder, ['wiringTag'])
   })
 
   test('should implement "at least one must pass" logic for tag permissions', async () => {

package/src/permissions.ts

@@ -10,7 +10,7 @@ import {
 } from './function/functions.types.js'
 import { pikkuState } from './pikku-state.js'
 import { ForbiddenError } from './errors/errors.js'
-import { freezeDedupe } from './utils.js'
+import { freezeDedupe, getTagGroups } from './utils.js'
 
 /**
  * This function validates permissions by iterating over permission groups and executing the corresponding permission functions. If all functions in at least one group return true, the permission is considered valid.
@@ -59,7 +59,7 @@ const verifyPermissions = async <Out = any>(
  * This function looks up permissions that was registered with registerPermission.
  * It's used internally by the framework to resolve permission references in metadata.
  *
- * @param {string} name - The unique name (pikkuFuncName) of the permission function.
+ * @param {string} name - The unique name (pikkuFuncId) of the permission function.
  * @returns {CorePikkuPermission | undefined} The permission function, or undefined if not found.
  *
  * @internal
@@ -125,7 +125,9 @@ const combinedPermissionsCache: Record<
   channel: {},
   queue: {},
   scheduler: {},
+  trigger: {},
   mcp: {},
+  agent: {},
   cli: {},
   workflow: {},
 }
@@ -193,11 +195,11 @@ const combinePermissions = (
           }
         }
       } else if (meta.type === 'tag') {
-        // Look up tag permission group from pikkuState
-        const group = pikkuState(packageName, 'permissions', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'permissions', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
+        )
+        for (const group of groups) {
           if (Array.isArray(group)) {
             resolved.push(...group)
           } else {
@@ -227,11 +229,11 @@ const combinePermissions = (
   if (funcInheritedPermissions) {
     for (const meta of funcInheritedPermissions) {
       if (meta.type === 'tag') {
-        // Look up tag permission group from pikkuState
-        const group = pikkuState(packageName, 'permissions', 'tagGroup')[
+        const groups = getTagGroups(
+          pikkuState(packageName, 'permissions', 'tagGroup'),
           meta.tag
-        ]
-        if (group) {
+        )
+        for (const group of groups) {
           if (Array.isArray(group)) {
             resolved.push(...group)
           } else {
@@ -299,7 +301,6 @@ export const runPermissions = async (
 
   // Check all combined permissions - at least one must pass if any exist
   if (allPermissions.length > 0) {
-    let permissioned = false
     for (const permission of allPermissions) {
       const result = await verifyPermissions(
         typeof permission === 'function' ? { permission } : permission,
@@ -308,13 +309,10 @@ export const runPermissions = async (
         wire
       )
       if (result) {
-        permissioned = true
-        // Continue executing all permissions (don't break early)
+        return
       }
     }
-    if (!permissioned) {
-      services.logger.debug('Permission denied - combined permissions')
-      throw new ForbiddenError('Permission denied')
-    }
+    services.logger.debug('Permission denied - combined permissions')
+    throw new ForbiddenError('Permission denied')
   }
 }

package/src/pikku-state.ts

@@ -5,6 +5,7 @@ import {
   MCPToolMeta,
   MCPPromptMeta,
 } from './wirings/mcp/mcp.types.js'
+import { AIAgentMeta } from './wirings/ai-agent/ai-agent.types.js'
 import { ScheduledTasksMeta } from './wirings/scheduler/scheduler.types.js'
 import { TriggerMeta } from './wirings/trigger/trigger.types.js'
 
@@ -95,23 +96,26 @@ const createEmptyPackageState = (): PikkuPackageState => ({
   },
   workflows: {
     registrations: new Map(),
-    graphRegistrations: new Map(),
-    wirings: new Map(),
-    graphWirings: new Map(),
     meta: {},
   },
   trigger: {
+    functions: new Map(),
     triggers: new Map(),
+    triggerSources: new Map(),
     meta: {} as TriggerMeta,
+    sourceMeta: {},
   },
   mcp: {
     resources: new Map(),
     resourcesMeta: {} as MCPResourceMeta,
-    tools: new Map(),
     toolsMeta: {} as MCPToolMeta,
     prompts: new Map(),
     promptsMeta: {} as MCPPromptMeta,
   },
+  agent: {
+    agents: new Map(),
+    agentsMeta: {} as AIAgentMeta,
+  },
   cli: {
     meta: { programs: {}, renderers: {} },
     programs: {},
@@ -119,24 +123,28 @@ const createEmptyPackageState = (): PikkuPackageState => ({
   middleware: {
     tagGroup: {},
     httpGroup: {},
-    tagGroupMeta: {},
-    httpGroupMeta: {},
+  },
+  channelMiddleware: {
+    tagGroup: {},
   },
   permissions: {
     tagGroup: {},
     httpGroup: {},
-    tagGroupMeta: {},
-    httpGroupMeta: {},
   },
   misc: {
     errors: new Map(),
     schemas: new Map(),
     middleware: {},
+    channelMiddleware: {},
     permissions: {},
   },
+  models: {
+    config: null,
+  },
   package: {
     factories: null,
     singletonServices: null,
+    metaDir: null,
   },
 })
 
@@ -170,6 +178,10 @@ if (!globalThis.pikkuState) {
   resetPikkuState()
 }
 
+export const getPikkuMetaDir = (packageName?: string | null): string | null => {
+  return pikkuState(packageName ?? null, 'package', 'metaDir')
+}
+
 /**
  * Register service factories for an external package.
  * These factories are used to create services when the package's functions are invoked.

package/src/run-tests-script.test.ts

@@ -0,0 +1,49 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const thisDir = path.dirname(fileURLToPath(import.meta.url))
+const packageRoot = path.resolve(thisDir, '..')
+const runTestsScriptPath = path.join(packageRoot, 'run-tests.sh')
+
+describe('run-tests.sh discovery behavior', () => {
+  test('returns success by default when no tests are found', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikku-core-tests-'))
+    const srcDir = path.join(tempDir, 'src')
+    fs.mkdirSync(srcDir, { recursive: true })
+    fs.copyFileSync(runTestsScriptPath, path.join(tempDir, 'run-tests.sh'))
+
+    const result = spawnSync('bash', ['run-tests.sh'], {
+      cwd: tempDir,
+      encoding: 'utf8',
+      env: { ...process.env, CI: 'false' },
+    })
+
+    assert.equal(result.status, 0)
+    assert.match(result.stdout, /No test files found matching pattern/)
+
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  test('returns failure in strict mode when no tests are found', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pikku-core-tests-'))
+    const srcDir = path.join(tempDir, 'src')
+    fs.mkdirSync(srcDir, { recursive: true })
+    fs.copyFileSync(runTestsScriptPath, path.join(tempDir, 'run-tests.sh'))
+
+    const result = spawnSync('bash', ['run-tests.sh'], {
+      cwd: tempDir,
+      encoding: 'utf8',
+      env: { ...process.env, STRICT_TEST_DISCOVERY: '1' },
+    })
+
+    assert.equal(result.status, 1)
+    assert.match(result.stdout, /No test files found matching pattern/)
+
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+})

package/src/schema.ts

@@ -1,8 +1,14 @@
 import { Logger } from './services/logger.js'
 import { SchemaService } from './services/schema-service.js'
-import { UnprocessableContentError } from './errors/errors.js'
+import {
+  MissingSchemaError,
+  UnprocessableContentError,
+} from './errors/errors.js'
 import { pikkuState } from './pikku-state.js'
 
+const schemaKey = (name: string, packageName: string | null): string =>
+  packageName ? `${packageName}:${name}` : name
+
 /**
  * Adds a schema to the schemas map for a specific package.
  * @param name - The name of the schema.
@@ -43,9 +49,11 @@ export const compileAllSchemas = (
   if (!schemaService) {
     throw new Error('SchemaService needs to be defined to load schemas')
   }
-  const schemas = pikkuState(null, 'misc', 'schemas')
-  for (const [name, schema] of schemas) {
-    schemaService.compileSchema(name, schema)
+  for (const [pkgName, packageState] of globalThis.pikkuState!) {
+    const resolvedPkgName = pkgName === '__main__' ? null : pkgName
+    for (const [name, schema] of packageState.misc.schemas) {
+      schemaService.compileSchema(schemaKey(name, resolvedPkgName), schema)
+    }
   }
   validateAllSchemasLoaded(logger, schemaService)
 }
@@ -61,7 +69,7 @@ const validateAllSchemasLoaded = (
 
   for (const routePaths of Object.values(routesMeta)) {
     for (const meta of Object.values(routePaths)) {
-      const inputs = pikkuState(null, 'function', 'meta')[meta.pikkuFuncName]
+      const inputs = pikkuState(null, 'function', 'meta')[meta.pikkuFuncId]
         ?.inputs
       const input = inputs?.[0]
       if (!input || validators.has(input)) {
@@ -121,10 +129,7 @@ export const validateSchema = async (
         return
       }
     }
-    logger.debug(
-      `[validateSchema] Validating schema '${schemaName}' for package '${packageName ?? 'main'}' with data:`,
-      JSON.stringify(data)
-    )
+    const key = schemaKey(schemaName, packageName)
     const schemas = pikkuState(packageName, 'misc', 'schemas')
     const schema = schemas.get(schemaName)
     if (schema === undefined) {
@@ -132,13 +137,11 @@ export const validateSchema = async (
       logger.error(
         `Schema '${schemaName}' not found for package '${packageName ?? 'main'}'. Available schemas: ${availableSchemas.join(', ') || '(none)'}`
       )
-    } else {
-      logger.debug(
-        `[validateSchema] Found schema '${schemaName}':`,
-        JSON.stringify(schema)
+      throw new MissingSchemaError(
+        `Schema '${schemaName}' not found. Ensure schema generation has been run.`
       )
     }
-    await schemaService.compileSchema(schemaName, schema)
-    await schemaService.validateSchema(schemaName, data)
+    await schemaService.compileSchema(key, schema)
+    await schemaService.validateSchema(key, data)
   }
 }

package/src/services/ai-agent-runner-service.ts

@@ -0,0 +1,29 @@
+import {
+  AIMessage,
+  AIAgentStep,
+  AIAgentToolDef,
+  AIStreamChannel,
+} from '../wirings/ai-agent/ai-agent.types.js'
+
+export type AIAgentRunnerParams = {
+  model: string
+  temperature?: number
+  instructions: string
+  messages: AIMessage[]
+  tools: AIAgentToolDef[]
+  maxSteps: number
+  toolChoice: 'auto' | 'required' | 'none'
+  outputSchema?: Record<string, unknown>
+}
+
+export type AIAgentRunnerResult = {
+  text: string
+  object?: unknown
+  steps: AIAgentStep[]
+  usage: { inputTokens: number; outputTokens: number }
+}
+
+export interface AIAgentRunnerService {
+  stream(params: AIAgentRunnerParams, channel: AIStreamChannel): Promise<void>
+  run(params: AIAgentRunnerParams): Promise<AIAgentRunnerResult>
+}

package/src/services/ai-run-state-service.ts

@@ -0,0 +1,20 @@
+import {
+  AgentRunState,
+  PendingApproval,
+} from '../wirings/ai-agent/ai-agent.types.js'
+
+export type CreateRunInput = Omit<AgentRunState, 'runId'>
+
+export interface AIRunStateService {
+  createRun(run: CreateRunInput): Promise<string>
+  updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>
+  getRun(runId: string): Promise<AgentRunState | null>
+  getRunsByThread(threadId: string): Promise<AgentRunState[]>
+  resolveApproval(
+    toolCallId: string,
+    status: 'approved' | 'denied'
+  ): Promise<void>
+  findRunByToolCallId(
+    toolCallId: string
+  ): Promise<{ run: AgentRunState; approval: PendingApproval } | null>
+}

package/src/services/ai-storage-service.ts

@@ -0,0 +1,39 @@
+import { AIThread, AIMessage } from '../wirings/ai-agent/ai-agent.types.js'
+
+export interface AIStorageService {
+  createThread(
+    resourceId: string,
+    options?: {
+      threadId?: string
+      title?: string
+      metadata?: Record<string, unknown>
+    }
+  ): Promise<AIThread>
+
+  getThread(threadId: string): Promise<AIThread>
+
+  getThreads(resourceId: string): Promise<AIThread[]>
+
+  deleteThread(threadId: string): Promise<void>
+
+  getMessages(
+    threadId: string,
+    options?: {
+      lastN?: number
+      cursor?: string
+    }
+  ): Promise<AIMessage[]>
+
+  saveMessages(threadId: string, messages: AIMessage[]): Promise<void>
+
+  getWorkingMemory(
+    id: string,
+    scope: 'resource' | 'thread'
+  ): Promise<Record<string, unknown> | null>
+
+  saveWorkingMemory(
+    id: string,
+    scope: 'resource' | 'thread',
+    data: Record<string, unknown>
+  ): Promise<void>
+}

package/src/services/deployment-service.ts

@@ -0,0 +1,22 @@
+export interface DeploymentServiceConfig {
+  heartbeatInterval?: number
+  heartbeatTtl?: number
+}
+
+export interface DeploymentConfig {
+  deploymentId: string
+  endpoint: string
+  functions?: string[]
+}
+
+export interface DeploymentInfo {
+  deploymentId: string
+  endpoint: string
+}
+
+export interface DeploymentService {
+  init(): Promise<void>
+  start(config: DeploymentConfig): Promise<void>
+  stop(): Promise<void>
+  findFunction(name: string): Promise<DeploymentInfo[]>
+}