@pikku/inspector 0.12.75 → 0.12.81

package/src/add/validate-workflow-graph-addons.test.ts

@@ -1,102 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-import { ErrorCode } from '../error-codes.js'
-
-function makeLogger(
-  criticals: Array<{ code: string; message: string }>
-): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: () => {},
-    critical: (code, message) => criticals.push({ code, message }),
-    hasCriticalErrors: () => criticals.length > 0,
-  }
-}
-
-describe('validateWorkflowGraphAddons', () => {
-  test('a graph node referencing graph: without @pikku/addon-graph wired raises PKU642', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-graph-addon-'))
-    const stepFile = join(rootDir, 'my.steps.ts')
-    const graphFile = join(rootDir, 'my.graph.ts')
-
-    await writeFile(
-      stepFile,
-      [
-        "import { pikkuSessionlessFunc } from '@pikku/core'",
-        'export const notify = pikkuSessionlessFunc({ func: async () => ({ sent: true }) })',
-      ].join('\n')
-    )
-    await writeFile(
-      graphFile,
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'my-graph',",
-        '  nodes: {',
-        "    setFields: 'graph:editFields',",
-        "    notify: 'notify',",
-        '  },',
-        "  config: { setFields: { next: 'notify' }, notify: {} },",
-        '})',
-      ].join('\n')
-    )
-
-    try {
-      const criticals: Array<{ code: string; message: string }> = []
-      await inspect(makeLogger(criticals), [stepFile, graphFile], { rootDir })
-      const hit = criticals.find(
-        (c) => c.code === ErrorCode.WORKFLOW_GRAPH_ADDON_NOT_WIRED
-      )
-      assert.ok(hit, 'expected a WORKFLOW_GRAPH_ADDON_NOT_WIRED critical')
-      assert.match(hit!.message, /@pikku\/addon-graph is not wired/)
-      assert.match(hit!.message, /scaffold/)
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('a graph with only user RPCs raises no addon-graph critical', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-graph-addon-ok-'))
-    const stepFile = join(rootDir, 'my.steps.ts')
-    const graphFile = join(rootDir, 'my.graph.ts')
-
-    await writeFile(
-      stepFile,
-      [
-        "import { pikkuSessionlessFunc } from '@pikku/core'",
-        'export const assess = pikkuSessionlessFunc({ func: async () => ({ ok: true }) })',
-        'export const notify = pikkuSessionlessFunc({ func: async () => ({ sent: true }) })',
-      ].join('\n')
-    )
-    await writeFile(
-      graphFile,
-      [
-        "import { pikkuWorkflowGraph } from '@pikku/core/workflow'",
-        'export const myGraph = pikkuWorkflowGraph({',
-        "  name: 'my-graph',",
-        "  nodes: { assess: 'assess', notify: 'notify' },",
-        "  config: { assess: { next: 'notify' }, notify: {} },",
-        '})',
-      ].join('\n')
-    )
-
-    try {
-      const criticals: Array<{ code: string; message: string }> = []
-      await inspect(makeLogger(criticals), [stepFile, graphFile], { rootDir })
-      const hit = criticals.find(
-        (c) => c.code === ErrorCode.WORKFLOW_GRAPH_ADDON_NOT_WIRED
-      )
-      assert.equal(hit, undefined, 'no addon-graph critical expected')
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/add/wire-name-literal.test.ts

@@ -1,117 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import { ErrorCode } from '../error-codes.js'
-import type { InspectorLogger } from '../types.js'
-
-const makeLogger = (criticals: Array<{ code: ErrorCode; message: string }>) =>
-  ({
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }) => {
-      criticals.push({ code, message })
-    },
-    critical: (code: ErrorCode, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  }) satisfies InspectorLogger
-
-describe('wiring name must be a string literal', () => {
-  test('logs a critical error when a queue worker name is a const reference', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-nonliteral-name-'))
-    const file = join(rootDir, 'queue.ts')
-
-    await writeFile(
-      file,
-      [
-        "import { pikkuSessionlessFunc, wireQueueWorker } from '@pikku/core'",
-        'const QUEUE_NAME = "stripe-webhook-event"',
-        'export const handler = pikkuSessionlessFunc({',
-        '  func: async () => ({ ok: true })',
-        '})',
-        'wireQueueWorker({',
-        '  name: QUEUE_NAME,',
-        '  func: handler,',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: ErrorCode; message: string }> = []
-    try {
-      await inspect(makeLogger(criticals), [file], { rootDir })
-      const hit = criticals.find(
-        (entry) => entry.code === ErrorCode.NON_LITERAL_WIRE_NAME
-      )
-      assert.ok(hit, 'expected NON_LITERAL_WIRE_NAME critical')
-      assert.match(hit!.message, /QUEUE_NAME/)
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('logs a critical error when a secret id is a const reference', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-nonliteral-secret-'))
-    const file = join(rootDir, 'secret.ts')
-
-    await writeFile(
-      file,
-      [
-        "import { defineSecret } from '@pikku/core'",
-        'const SECRET_ID = "STRIPE_SECRET_KEY"',
-        'defineSecret({',
-        '  secretId: SECRET_ID,',
-        "  name: 'Stripe secret key',",
-        "  displayName: 'Stripe secret key',",
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: ErrorCode; message: string }> = []
-    try {
-      await inspect(makeLogger(criticals), [file], { rootDir })
-      const hit = criticals.find(
-        (entry) => entry.code === ErrorCode.NON_LITERAL_WIRE_NAME
-      )
-      assert.ok(hit, 'expected NON_LITERAL_WIRE_NAME critical')
-      assert.match(hit!.message, /SECRET_ID/)
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('does not flag a queue worker whose name is an inline literal', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-literal-name-'))
-    const file = join(rootDir, 'queue.ts')
-
-    await writeFile(
-      file,
-      [
-        "import { pikkuSessionlessFunc, wireQueueWorker } from '@pikku/core'",
-        'export const handler = pikkuSessionlessFunc({',
-        '  func: async () => ({ ok: true })',
-        '})',
-        'wireQueueWorker({',
-        "  name: 'stripe-webhook-event',",
-        '  func: handler,',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: ErrorCode; message: string }> = []
-    try {
-      await inspect(makeLogger(criticals), [file], { rootDir })
-      const hit = criticals.find(
-        (entry) => entry.code === ErrorCode.NON_LITERAL_WIRE_NAME
-      )
-      assert.equal(hit, undefined)
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/error-codes-emitted.test.ts

@@ -1,76 +0,0 @@
-import { test } from 'node:test'
-import { strict as assert } from 'node:assert'
-import { readFileSync, readdirSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-/**
- * Guards against dead `ErrorCode` registry entries.
- *
- * Every value in the `ErrorCode` enum must have at least one emission site in
- * the framework source — a `ErrorCode.<NAME>` reference or the raw `PKU###`
- * string in a non-test `.ts` file under `packages/*​/src`. A code that is
- * defined but never thrown is a dead entry: it can never appear in a user's
- * terminal, yet it still demands a docs page and clutters the registry. This
- * test fails and names any such entries so they get wired up or removed rather
- * than silently accumulating.
- */
-
-const here = dirname(fileURLToPath(import.meta.url))
-const packagesDir = join(here, '..', '..')
-const errorCodesFile = join(here, 'error-codes.ts')
-
-const enumMembers = [
-  ...readFileSync(errorCodesFile, 'utf8').matchAll(
-    /^\s*([A-Z0-9_]+)\s*=\s*'(PKU\d+)'/gm
-  ),
-].map((m) => ({ name: m[1], code: m[2] }))
-
-const collectSource = () => {
-  const contents: string[] = []
-  for (const pkg of readdirSync(packagesDir, { withFileTypes: true })) {
-    if (!pkg.isDirectory()) continue
-    const srcDir = join(packagesDir, pkg.name, 'src')
-    let entries
-    try {
-      entries = readdirSync(srcDir, { recursive: true, withFileTypes: true })
-    } catch {
-      continue
-    }
-    for (const entry of entries) {
-      if (!entry.isFile()) continue
-      const name = entry.name
-      if (
-        !name.endsWith('.ts') ||
-        name.endsWith('.d.ts') ||
-        name.endsWith('.test.ts') ||
-        name === 'error-codes.ts'
-      ) {
-        continue
-      }
-      contents.push(readFileSync(join(entry.parentPath, name), 'utf8'))
-    }
-  }
-  return contents.join('\n')
-}
-
-test('every ErrorCode value has an emission site in the source', () => {
-  assert.ok(
-    enumMembers.length > 0,
-    'Failed to parse any ErrorCode members from error-codes.ts'
-  )
-
-  const source = collectSource()
-
-  const dead = enumMembers.filter(
-    ({ name, code }) =>
-      !source.includes(`ErrorCode.${name}`) && !source.includes(code)
-  )
-
-  assert.deepEqual(
-    dead.map(({ code, name }) => `${code} ${name}`),
-    [],
-    `Dead ErrorCode entries (defined but never emitted). Wire them to a diagnostic or delete them:\n` +
-      dead.map(({ code, name }) => `  - ${code} ${name}`).join('\n')
-  )
-})

package/src/error-codes.ts

@@ -1,145 +0,0 @@
-/**
- * Error code system for Pikku CLI and Inspector
- *
- * Each error has a unique code and links to documentation at pikku.dev
- *
- * Error codes use random 3-digit numbers to avoid implying a sequential order.
- * Each code links to detailed documentation and troubleshooting steps.
- */
-
-export enum ErrorCode {
-  // Validation errors
-  MISSING_NAME = 'PKU111',
-  NON_LITERAL_WIRE_NAME = 'PKU118',
-  MISSING_DESCRIPTION = 'PKU123',
-  INVALID_VALUE = 'PKU124',
-  MISSING_URI = 'PKU220',
-  MISSING_FUNC = 'PKU236',
-  INVALID_TAGS_TYPE = 'PKU247',
-  MISSING_TITLE = 'PKU370',
-  MISSING_QUEUE_NAME = 'PKU384',
-  MISSING_CHANNEL_NAME = 'PKU400',
-  CLI_CLIENTSIDE_RENDERER_HAS_SERVICES = 'PKU672',
-  SCENARIO_HAS_SERVICES = 'PKU673',
-  EXPECT_EVENTUALLY_SCENARIO_ONLY = 'PKU675',
-  SCENARIO_STEP_NEEDS_ACTOR = 'PKU677',
-  SCENARIO_STEP_TARGET_NOT_STATIC = 'PKU678',
-  SCENARIO_NOT_EXTRACTABLE = 'PKU679',
-  SCENARIO_HAS_NO_ASSERTION = 'PKU680',
-  SCENARIO_STEP_PROSE_NAMES_ACTOR = 'PKU681',
-  WORKFLOW_ORCHESTRATOR_NOT_CONFIGURED = 'PKU600',
-  INVALID_DSL_WORKFLOW = 'PKU641',
-  WORKFLOW_GRAPH_ADDON_NOT_WIRED = 'PKU642',
-  COMPLEX_WORKFLOW_NOT_ALLOWED = 'PKU643',
-
-  // Remote addon (wireRemoteAddon) validation
-  REMOTE_ADDON_NOT_DEV_DEPENDENCY = 'PKU338',
-  REMOTE_ADDON_AUTH_UNRESOLVED = 'PKU339',
-  ADDON_NOT_INSTALLED = 'PKU340',
-
-  // Database schema codegen warnings
-  DB_COLUMN_NAME_TYPE_CONTRADICTION = 'PKU480',
-  DB_JSON_COLUMN_UNTYPED = 'PKU481',
-  DB_FORMAT_ON_NON_STRING = 'PKU482',
-  DB_SECRET_COLUMN_STORED_PLAIN = 'PKU483',
-  DB_FORM_ON_NON_STRING = 'PKU484',
-  DB_DEFAULT_SCHEMA_NAME_COLLISION = 'PKU485',
-
-  // Configuration errors
-  SCHEMA_GENERATION_ERROR = 'PKU456',
-  SCHEMA_REFERENCE_UNRESOLVED = 'PKU463',
-  INLINE_SCHEMA = 'PKU489',
-
-  // Function errors
-  FUNCTION_METADATA_NOT_FOUND = 'PKU559',
-
-  // Auth errors
-  DUPLICATE_AUTH_DEFINITION = 'PKU581',
-  AUTH_NOT_EXPORTED = 'PKU582',
-
-  // Single-declaration constructs — one call site per codebase.
-  // PKU583 (defineScope) and PKU584 (defineSystemRole) are retired, not free:
-  // scopes and roles held this rule until the generated `admin` tree made it
-  // unsatisfiable, and get it back once `admin` is a default scope nobody
-  // declares. Do not reuse those two numbers for anything else.
-  DUPLICATE_PERSONAS_DEFINITION = 'PKU585',
-
-  // HTTP Route errors
-  ROUTE_PARAM_MISMATCH = 'PKU571',
-  ROUTE_QUERY_MISMATCH = 'PKU572',
-  AUTH_DISABLED_REQUIRES_SESSIONLESS = 'PKU573',
-  EXPOSED_FUNCTION_HAS_NO_GATE = 'PKU574',
-  TAG_RESOLVES_TO_NO_MIDDLEWARE = 'PKU575',
-  PERMISSIONS_IN_BODY_NOT_ALLOWED = 'PKU576',
-
-  // Versioning errors
-  DUPLICATE_FUNCTION_VERSION = 'PKU850',
-  DUPLICATE_FUNCTION_NAME = 'PKU851',
-
-  // Contract versioning errors
-  MANIFEST_MISSING = 'PKU860',
-  FUNCTION_VERSION_MODIFIED = 'PKU861',
-  CONTRACT_CHANGED_REQUIRES_BUMP = 'PKU862',
-  VERSION_REGRESSION_OR_CONFLICT = 'PKU863',
-  VERSION_GAP_NOT_ALLOWED = 'PKU864',
-  MANIFEST_INTEGRITY_ERROR = 'PKU865',
-
-  // Model configuration errors
-  MISSING_MODEL = 'PKU145',
-  INVALID_MODEL = 'PKU146',
-
-  // Agent tool reference errors
-  AGENT_TOOL_UNKNOWN_NAMESPACE = 'PKU152',
-  AGENT_TOOL_NOT_FOUND = 'PKU153',
-  AGENT_TOOL_MISSING_DESCRIPTION = 'PKU154',
-
-  // Agent scorer reference errors
-  AGENT_SCORER_NOT_FOUND = 'PKU155',
-
-  // File structure errors
-  SCHEMA_AND_WIRING_COLOCATED = 'PKU490',
-
-  // Schema authoring errors
-  SCHEMA_TRANSFORM_NOT_SUPPORTED = 'PKU491',
-
-  // Optimization diagnostics
-  SERVICES_NOT_DESTRUCTURED = 'PKU410',
-  WIRES_NOT_DESTRUCTURED = 'PKU411',
-  FUNCTION_DYNAMIC_IMPORT = 'PKU498',
-
-  // Dependency integrity errors
-  DUPLICATE_CORE_VERSION = 'PKU717',
-  CORE_VERSION_SKEW = 'PKU718',
-  SPLIT_TYPE_IDENTITY = 'PKU719',
-  SINGLETON_SERVICES_TYPE_UNRESOLVED = 'PKU724',
-
-  // Data classification errors
-  PII_IN_OUTPUT = 'PKU910',
-
-  // Addon authoring errors
-  ADDON_WIRING_NOT_ALLOWED = 'PKU920',
-  ADDON_CONTRACT_HANDLERS_NOT_ALLOWED = 'PKU921',
-
-  RPC_INVOCATION_TYPE_CAST = 'PKU940',
-
-  // Secret boundary errors
-  SECRET_SERVICE_ALIASED = 'PKU950',
-  SECRET_NOT_DECLARED = 'PKU951',
-  SECRET_KEY_NOT_STATIC = 'PKU952',
-  SECRET_REVEALED_INTO_SINK = 'PKU953',
-  PII_INTO_SINK = 'PKU954',
-}
-
-/**
- * Severity of a tracked, coded diagnostic. `critical` always blocks the build;
- * `error`/`warn` only block when the CLI is told to via `--fail-on-error` /
- * `--fail-on-warn` (default: critical only). All severities are still printed.
- */
-export type DiagnosticSeverity = 'warn' | 'error' | 'critical'
-
-/** A coded diagnostic emitted via `logger.diagnostic(...)`. */
-export interface CodedDiagnostic {
-  severity: DiagnosticSeverity
-  code: ErrorCode
-  message: string
-}

package/src/index.ts

@@ -1,66 +0,0 @@
-export { inspect, getInitialInspectorState } from './inspector.js'
-export type { TypesMap } from './types-map.js'
-export type {
-  AddonConfig,
-  AuthDefinition,
-  InspectorDiagnostic,
-  InspectorFilters,
-  InspectorHTTPState,
-  InspectorLogger,
-  InspectorMiddlewareState,
-  InspectorOptions,
-  InspectorPermissionState,
-  InspectorState,
-  MetaInputTypes,
-  MiddlewareGroupMeta,
-  MiddlewareRegistration,
-  SchemaRef,
-} from './types.js'
-export type { FilesAndMethodsErrors } from './utils/get-files-and-methods.js'
-export { ErrorCode } from './error-codes.js'
-export type { DiagnosticSeverity, CodedDiagnostic } from './error-codes.js'
-export { AUTH_HANDLER_FUNC_ID } from './add/add-auth.js'
-export {
-  SCENARIO_INSTRUMENTATION_FUNCTIONS,
-  isScenarioInstrumentationFunction,
-} from './add/scenario-instrumentation.js'
-export type { ScenarioInstrumentationFunction } from './add/scenario-instrumentation.js'
-export {
-  serializeInspectorState,
-  deserializeInspectorState,
-} from './utils/serialize-inspector-state.js'
-export type { SerializableInspectorState } from './utils/serialize-inspector-state.js'
-export { filterInspectorState } from './utils/filter-inspector-state.js'
-export { resolveDeployTarget } from './utils/resolve-deploy-target.js'
-export {
-  generateCustomTypes,
-  sanitizeTypeName,
-} from './utils/custom-types-generator.js'
-export { unresolvedSchemaReferences } from './utils/post-process.js'
-export type { SurfaceUsageCounts } from './utils/extract-surface-usage.js'
-export {
-  createEmptyManifest,
-  serializeManifest,
-} from './utils/contract-hashes.js'
-export type {
-  ContractEntry,
-  VersionHashEntry,
-  VersionValidateError,
-  VersionManifest,
-  VersionManifestEntry,
-} from './utils/contract-hashes.js'
-export type { InspectorFeature, InspectorFeatureEntry } from './types.js'
-export { serializeMCPJson } from './utils/serialize-mcp-json.js'
-export type { OpenAPISpecInfo } from './utils/serialize-openapi-json.js'
-export {
-  deserializeDslWorkflow,
-  deserializeGraphWorkflow,
-  deserializeAllDslWorkflows,
-} from './utils/workflow/dsl/index.js'
-export { getFilesAndMethods } from './utils/get-files-and-methods.js'
-export { resolveFunctionMeta } from './utils/resolve-function-meta.js'
-export type {
-  SerializedWorkflowGraph,
-  SerializedWorkflowGraphs,
-} from './utils/workflow/graph/index.js'
-export { resolveCoreType } from './utils/resolve-core-type.js'