polen 0.10.0-next.9 → 0.10.0

package/src/lib/github-actions/step.test.ts

@@ -1,149 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { z } from 'zod/v4'
-import { createStep } from './step.ts'
-
-describe('defineWorkflowStep', () => {
-  const mockCore = {
-    startGroup: vi.fn(),
-    endGroup: vi.fn(),
-    debug: vi.fn(),
-    info: vi.fn(),
-    warning: vi.fn(),
-    error: vi.fn(),
-    setOutput: vi.fn(),
-  } as any
-
-  const mockContext = {
-    core: mockCore,
-    github: {} as any,
-    context: {} as any,
-    $: {} as any,
-    fs: {} as any,
-  } as any
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it('executes step with validated inputs', async () => {
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step',
-      inputs: z.object({
-        required: z.string(),
-        optional: z.string().optional(),
-      }),
-      outputs: z.object({ result: z.string() }),
-      async run({ inputs }) {
-        return { result: `Got ${inputs.required}` }
-      },
-    })
-
-    // Create context with PR controller
-    const contextWithPR = {
-      ...mockContext,
-      pr: {
-        number: 0,
-        isActive: false,
-        comment: vi.fn(),
-        deleteComment: vi.fn(),
-        getComments: vi.fn(),
-      },
-    }
-
-    const result = await TestStep.run({
-      ...contextWithPR,
-      inputs: {
-        required: 'value',
-        optional: 'optional-value',
-      },
-    })
-
-    expect(result).toEqual({ result: 'Got value' })
-  })
-
-  it('validates output types', async () => {
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step',
-      inputs: z.object({
-        required: z.string(),
-      }),
-      outputs: z.object({ result: z.string() }),
-      async run({ inputs }) {
-        return { result: inputs.required }
-      },
-    })
-
-    // Outputs are validated in the runner, not in execute
-    expect(TestStep.definition.outputsSchema).toBeDefined()
-    expect(TestStep.definition.inputsSchema).toBeDefined()
-  })
-
-  it('step definition contains all metadata', async () => {
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step',
-      inputs: z.object({
-        number: z.number(),
-      }),
-      outputs: z.object({ result: z.string() }),
-      async run() {
-        return { result: 'ok' }
-      },
-    })
-
-    expect(TestStep.definition.name).toBe('test-step')
-    expect(TestStep.definition.description).toBe('Test step')
-    expect(TestStep.definition.inputsSchema).toBeDefined()
-    expect(TestStep.definition.outputsSchema).toBeDefined()
-  })
-
-  // todo: this test is now a static type error, update to refelct that
-  // it('does not warn for non-object schemas', async () => {
-  //   const TestStep = defineStep({
-  //     name: 'test-step',
-  //     description: 'Test step',
-  //     inputs: z.string(),
-  //     outputs: z.object({ result: z.string() }),
-  //     async run({ inputs }) {
-  //       return { result: inputs }
-  //     },
-  //   })
-
-  //   await TestStep(mockContext, 'just-a-string')
-
-  //   expect(mockCore.warning).not.toHaveBeenCalled()
-  // })
-
-  it('always provides PR controller', async () => {
-    const mockPR = {
-      number: 123,
-      isActive: true,
-      comment: vi.fn(),
-      deleteComment: vi.fn(),
-      getComments: vi.fn(),
-    }
-
-    const contextWithPR = {
-      ...mockContext,
-      pr: mockPR,
-    }
-
-    const TestStep = createStep({
-      name: 'test-step',
-      description: 'Test step with PR',
-      inputs: z.object({}),
-      outputs: z.object({ isActive: z.boolean() }),
-      async run({ pr }) {
-        return { isActive: pr.isActive }
-      },
-    })
-
-    const result = await TestStep.run({
-      ...contextWithPR,
-      inputs: {},
-    })
-    expect(result).toEqual({ isActive: true })
-  })
-})

package/src/lib/github-actions/step.ts

@@ -1,232 +0,0 @@
-/**
- * Type-safe workflow step framework for GitHub Actions
- */
-
-// import type { Context } from '@actions/github/lib/context.ts'
-import type { GitHub } from '@actions/github/lib/utils.ts'
-import { z } from 'zod/v4'
-import type { GitController } from './git-controller.ts'
-import type { PullRequestController } from './pr-controller.ts'
-import type { Context, ContextSchema as RealContextSchema } from './schemas/context.ts'
-
-/**
- * Arguments passed to the step's run function.
- *
- * @template $Inputs - The validated input values based on your inputs schema
- * @template $Context - The GitHub Actions context (validated if context schema provided)
- */
-export interface Args<$Inputs extends Inputs = Inputs, $Context = Context> {
-  /** GitHub Actions core utilities for logging, setting outputs, etc. */
-  core: typeof import('@actions/core')
-
-  /** GitHub Actions context containing event payload, repo info, etc. */
-  context: $Context
-
-  /** Validated input values passed to the step */
-  inputs: $Inputs
-
-  /** Authenticated Octokit instance for GitHub API operations */
-  github: InstanceType<typeof GitHub>
-
-  /** zx's $ function for executing shell commands */
-  $: typeof import('zx').$
-
-  /** Node.js fs/promises module for file operations */
-  fs: typeof import('node:fs/promises')
-
-  /** PR controller for pull request operations (comment, review, etc.) */
-  pr: PullRequestController
-
-  /** Git controller for git operations (commit, push, etc.) without subprocess details */
-  git: GitController
-}
-
-export type Outputs = object
-
-export type Inputs = object
-
-type InputsSchema = z.ZodObject
-
-type OutputsSchema = z.ZodObject
-
-// This is a loose type because working with sub/sup schema types is complex, maybe not even workable, unclear, and not worth the effort
-type ContextSchema = z.Schema
-
-// Export the full step definition for runner
-export interface Step<
-  $InputsSchema extends InputsSchema = InputsSchema,
-  $OutputsSchema extends OutputsSchema = OutputsSchema,
-  $ContextSchema extends ContextSchema = ContextSchema,
-> {
-  definition: Definition<
-    $InputsSchema,
-    $OutputsSchema,
-    $ContextSchema
-  >
-  run: Runner<
-    z.output<$InputsSchema>,
-    z.output<$OutputsSchema>,
-    z.output<$ContextSchema>
-  >
-}
-
-export type Runner<
-  $Inputs extends Inputs = Inputs,
-  $Outputs extends Outputs = Outputs,
-  $Context = Context,
-> = (
-  context: Args<$Inputs, $Context>,
-) => Promise<$Outputs>
-
-// Generic workflow step definition
-export interface Definition<
-  $InputsSchema extends InputsSchema,
-  $OutputsSchema extends OutputsSchema,
-  $ContextSchema extends ContextSchema,
-> {
-  description?: string
-  name?: string
-  inputsSchema?: $InputsSchema
-  outputsSchema?: $OutputsSchema
-  contextSchema?: $ContextSchema
-}
-
-// Generic workflow step definition
-export interface CreateInput<
-  $InputsSchema extends InputsSchema,
-  $OutputsSchema extends OutputsSchema,
-  $ContextSchema extends z.Schema,
-> {
-  description?: string
-  name?: string
-  inputs?: $InputsSchema
-  outputs?: $OutputsSchema
-  context?: $ContextSchema
-  run: (
-    args: Args<z.output<$InputsSchema>, z.output<$ContextSchema>>,
-    // todo: Obj.isEmpty ...
-  ) => Promise<{} extends z.Infer<$OutputsSchema> ? void : z.Infer<$OutputsSchema>>
-}
-
-/**
- * Create a type-safe GitHub Actions workflow step with runtime validation.
- *
- * This is the main entry point for defining custom workflow steps that can be executed
- * by the GitHub Actions runner. It provides:
- * - Type-safe inputs/outputs with Zod schema validation
- * - Automatic GitHub Actions output handling (both individual outputs and bundled JSON)
- * - Context validation to ensure steps run in the correct workflow events
- * - Integration with GitHub API via Octokit
- * - Built-in error handling and logging
- *
- * @example Basic step with inputs and outputs
- * ```typescript
- * import { z } from 'zod'
- * import { GitHubActions } from '#lib/github-actions'
- *
- * export default GitHubActions.createStep({
- *   name: 'my-step',
- *   description: 'Processes some data and returns results',
- *   inputs: z.object({
- *     message: z.string(),
- *     count: z.number().optional().default(1),
- *   }),
- *   outputs: z.object({
- *     result: z.string(),
- *     processed: z.boolean(),
- *   }),
- *   async run({ inputs, core }) {
- *     core.info(`Processing: ${inputs.message}`)
- *
- *     return {
- *       result: inputs.message.toUpperCase(),
- *       processed: true,
- *     }
- *   }
- * })
- * ```
- *
- * @example Step with specific context requirements
- * ```typescript
- * export default GitHubActions.createStep({
- *   name: 'pr-only-step',
- *   description: 'This step only runs on pull requests',
- *   context: GitHubActions.PullRequestContext,
- *   outputs: z.object({
- *     pr_number: z.number(),
- *   }),
- *   async run({ context, core }) {
- *     const prNumber = context.payload.pull_request.number
- *     core.info(`Running on PR #${prNumber}`)
- *
- *     return { pr_number: prNumber }
- *   }
- * })
- * ```
- *
- * @example Using the GitHub API
- * ```typescript
- * export default GitHubActions.createStep({
- *   name: 'create-issue',
- *   description: 'Creates a GitHub issue',
- *   inputs: z.object({
- *     title: z.string(),
- *     body: z.string(),
- *   }),
- *   outputs: z.object({
- *     issue_number: z.number(),
- *     issue_url: z.string(),
- *   }),
- *   async run({ inputs, github, context }) {
- *     const issue = await github.rest.issues.create({
- *       owner: context.repo.owner,
- *       repo: context.repo.repo,
- *       title: inputs.title,
- *       body: inputs.body,
- *     })
- *
- *     return {
- *       issue_number: issue.data.number,
- *       issue_url: issue.data.html_url,
- *     }
- *   }
- * })
- * ```
- *
- * @param input - Step configuration object
- * @param input.name - Unique identifier for the step (used in logging and debugging)
- * @param input.description - Human-readable description of what the step does
- * @param input.inputs - Optional Zod schema for validating step inputs
- * @param input.outputs - Optional Zod schema for validating step outputs
- * @param input.context - Optional Zod schema for validating GitHub Actions context (event type)
- * @param input.run - Async function that implements the step logic
- *
- * @returns A Step object that can be executed by the GitHub Actions runner
- *
- * @remarks
- * - All outputs are automatically set as GitHub Actions outputs
- * - Boolean outputs are properly handled (use fromJSON in workflows)
- * - A special 'json' output contains all outputs bundled together
- * - The runner provides extensive logging and error handling
- * - Steps can access PR controller for pull request operations
- * - The `$` from zx is available for shell commands
- */
-export function createStep<
-  $InputsSchema extends InputsSchema,
-  $OutputsSchema extends OutputsSchema,
-  $ContextSchema extends ContextSchema = RealContextSchema,
->(
-  input: CreateInput<$InputsSchema, $OutputsSchema, $ContextSchema>,
-): Step<$InputsSchema, $OutputsSchema, $ContextSchema> {
-  const { run, inputs, outputs, context, ...rest } = input
-  const definition: Definition<$InputsSchema, $OutputsSchema, $ContextSchema> = {
-    ...rest,
-    inputsSchema: inputs,
-    outputsSchema: outputs,
-    contextSchema: context,
-  }
-  return {
-    definition,
-    run,
-  } as any
-}

package/src/lib/shiki/index.ts

@@ -1 +0,0 @@
-export * from './shiki.ts'

package/src/lib/shiki/shiki.test.ts

@@ -1,107 +0,0 @@
-import { expect, test } from 'vitest'
-import { getHighlighter, highlightCode } from './shiki.ts'
-
-test(`getHighlighter returns singleton instance`, async () => {
-  const highlighter1 = await getHighlighter()
-  const highlighter2 = await getHighlighter()
-
-  expect(highlighter1).toBe(highlighter2)
-})
-
-test(`highlightCode generates HTML with syntax highlighting`, async () => {
-  const code = `const hello = "world"`
-  const result = await highlightCode({
-    code,
-    lang: `javascript`,
-    theme: `light`,
-  })
-
-  expect(result).toContain(`<pre`)
-  expect(result).toContain(`shiki`)
-  expect(result).toContain(`hello`)
-  expect(result).toContain(`world`)
-})
-
-test(`highlightCode supports TypeScript`, async () => {
-  const code = `interface User { name: string }`
-  const result = await highlightCode({
-    code,
-    lang: `typescript`,
-    theme: `light`,
-  })
-
-  expect(result).toContain(`interface`)
-  expect(result).toContain(`User`)
-  expect(result).toContain(`string`)
-})
-
-test(`highlightCode supports GraphQL`, async () => {
-  const code = `type Query { user: User }`
-  const result = await highlightCode({
-    code,
-    lang: `graphql`,
-    theme: `light`,
-  })
-
-  expect(result).toContain(`type`)
-  expect(result).toContain(`Query`)
-  expect(result).toContain(`User`)
-})
-
-test(`highlightCode handles unknown language gracefully`, async () => {
-  const code = `some random text`
-  // Use 'text' as fallback for unknown languages
-  const result = await highlightCode({
-    code,
-    lang: `text`,
-    theme: `light`,
-  })
-
-  // Should still return highlighted HTML
-  expect(result).toContain(`<pre`)
-  expect(result).toContain(`some random text`)
-})
-
-test(`highlightCode applies line numbers when requested`, async () => {
-  const code = `line 1\nline 2\nline 3`
-  const result = await highlightCode({
-    code,
-    lang: `text`,
-    theme: `light`,
-    showLineNumbers: true,
-  })
-
-  expect(result).toContain(`data-line-numbers="true"`)
-})
-
-test(`highlightCode applies line highlighting`, async () => {
-  const code = `line 1\nline 2\nline 3`
-  const result = await highlightCode({
-    code,
-    lang: `text`,
-    theme: `light`,
-    highlightLines: [2],
-  })
-
-  expect(result).toContain(`data-highlighted="true"`)
-})
-
-test(`highlightCode supports both light and dark themes`, async () => {
-  const code = `const x = 1`
-
-  const lightResult = await highlightCode({
-    code,
-    lang: `javascript`,
-    theme: `light`,
-  })
-
-  const darkResult = await highlightCode({
-    code,
-    lang: `javascript`,
-    theme: `dark`,
-  })
-
-  // Both should contain theme CSS variables
-  expect(lightResult).toContain(`--shiki-light`)
-  expect(darkResult).toContain(`--shiki-dark`)
-})

package/src/lib/shiki/shiki.ts

@@ -1,161 +0,0 @@
-import {
-  transformerNotationDiff,
-  transformerNotationFocus,
-  transformerNotationHighlight,
-  transformerRenderWhitespace,
-} from '@shikijs/transformers'
-import { type BundledLanguage, type BundledTheme, createHighlighter, type Highlighter } from 'shiki'
-
-export interface ShikiOptions {
-  themes?: {
-    light: BundledTheme
-    dark: BundledTheme
-  }
-  langs?: BundledLanguage[]
-  defaultTheme?: 'light' | 'dark'
-}
-
-const DEFAULT_THEMES = {
-  light: `github-light` as BundledTheme,
-  dark: `tokyo-night` as BundledTheme,
-}
-
-const DEFAULT_LANGS: BundledLanguage[] = [
-  `typescript`,
-  `javascript`,
-  `jsx`,
-  `tsx`,
-  `graphql`,
-  `json`,
-  `yaml`,
-  `markdown`,
-  `bash`,
-  `shell`,
-  `css`,
-  `html`,
-  `sql`,
-  `python`,
-  `rust`,
-  `go`,
-  `java`,
-  `csharp`,
-  `php`,
-  `ruby`,
-  `swift`,
-  `kotlin`,
-  `scala`,
-  `r`,
-  `matlab`,
-  `latex`,
-  `dockerfile`,
-  `makefile`,
-  `nginx`,
-  `apache`,
-  `xml`,
-  `toml`,
-  `ini`,
-  `diff`,
-]
-
-// Singleton highlighter instance
-let highlighterInstance: Highlighter | null = null
-let highlighterPromise: Promise<Highlighter> | null = null
-
-export async function getHighlighter(options: ShikiOptions = {}): Promise<Highlighter> {
-  if (highlighterInstance) {
-    return highlighterInstance
-  }
-
-  if (!highlighterPromise) {
-    const themes = options.themes || DEFAULT_THEMES
-    const langs = options.langs || DEFAULT_LANGS
-
-    highlighterPromise = createHighlighter({
-      themes: [themes.light, themes.dark],
-      langs,
-    }).then(highlighter => {
-      highlighterInstance = highlighter
-      return highlighter
-    })
-  }
-
-  return highlighterPromise
-}
-
-export interface CodeHighlightOptions {
-  code: string
-  lang?: string
-  theme?: 'light' | 'dark'
-  showLineNumbers?: boolean
-  highlightLines?: number[]
-  diffLines?: { add: number[]; remove: number[] }
-  focusLines?: number[]
-  showInvisibles?: boolean
-}
-
-export async function highlightCode({
-  code,
-  lang = `text`,
-  theme = `light`,
-  showLineNumbers = false,
-  highlightLines = [],
-  diffLines,
-  focusLines = [],
-  showInvisibles = false,
-}: CodeHighlightOptions): Promise<string> {
-  const highlighter = await getHighlighter()
-
-  const themes = {
-    light: DEFAULT_THEMES.light,
-    dark: DEFAULT_THEMES.dark,
-  }
-
-  const transformers = []
-
-  // Add line numbers transformer if needed
-  if (showLineNumbers) {
-    // Custom line numbers will be handled in CSS
-    transformers.push({
-      name: `line-numbers`,
-      pre(node: any) {
-        node.properties[`data-line-numbers`] = `true`
-      },
-    })
-  }
-
-  // Add highlight transformer
-  if (highlightLines.length > 0) {
-    transformers.push({
-      name: `highlight-lines`,
-      line(node: any, line: number) {
-        if (highlightLines.includes(line)) {
-          node.properties[`data-highlighted`] = `true`
-        }
-      },
-    })
-  }
-
-  // Add standard transformers
-  transformers.push(
-    transformerNotationHighlight(),
-    transformerNotationDiff(),
-    transformerNotationFocus(),
-  )
-
-  if (showInvisibles) {
-    transformers.push(transformerRenderWhitespace())
-  }
-
-  // Generate HTML with CSS variables for theme switching
-  const html = highlighter.codeToHtml(code, {
-    lang,
-    themes,
-    defaultColor: false,
-    transformers,
-  })
-
-  return html
-}
-
-// Re-export types
-export type { BundledLanguage, BundledTheme, Highlighter } from 'shiki'