@murphai/murph 1.3.0 → 1.3.2

package/node_modules/incur/src/Fetch.test.ts

@@ -1,285 +0,0 @@
-import { describe, expect, test } from 'vitest'
-
-import { app } from '../test/fixtures/hono-api.js'
-import * as Fetch from './Fetch.js'
-
-describe('parseArgv', () => {
-  test('bare tokens → path segments', () => {
-    const input = Fetch.parseArgv(['users', 'list'])
-    expect(input.path).toBe('/users/list')
-  })
-
-  test('empty argv → root path', () => {
-    const input = Fetch.parseArgv([])
-    expect(input.path).toBe('/')
-  })
-
-  test('single token', () => {
-    const input = Fetch.parseArgv(['health'])
-    expect(input.path).toBe('/health')
-  })
-
-  test('default method is GET', () => {
-    const input = Fetch.parseArgv(['users'])
-    expect(input.method).toBe('GET')
-  })
-
-  test('-X sets method', () => {
-    const input = Fetch.parseArgv(['users', '-X', 'POST'])
-    expect(input.method).toBe('POST')
-  })
-
-  test('--method sets method', () => {
-    const input = Fetch.parseArgv(['users', '--method', 'DELETE'])
-    expect(input.method).toBe('DELETE')
-  })
-
-  test('default POST when body present', () => {
-    const input = Fetch.parseArgv(['users', '--body', '{"name":"Eve"}'])
-    expect(input.method).toBe('POST')
-  })
-
-  test('-d sets body', () => {
-    const input = Fetch.parseArgv(['users', '-d', '{"name":"Bob"}'])
-    expect(input.body).toBe('{"name":"Bob"}')
-    expect(input.method).toBe('POST')
-  })
-
-  test('--data sets body', () => {
-    const input = Fetch.parseArgv(['users', '--data', '{"x":1}'])
-    expect(input.body).toBe('{"x":1}')
-  })
-
-  test('explicit method overrides body default', () => {
-    const input = Fetch.parseArgv(['users', '-X', 'PUT', '-d', '{"name":"Bob"}'])
-    expect(input.method).toBe('PUT')
-  })
-
-  test('-H sets header', () => {
-    const input = Fetch.parseArgv(['users', '-H', 'X-Api-Key: secret'])
-    expect(input.headers.get('X-Api-Key')).toBe('secret')
-  })
-
-  test('--header sets header', () => {
-    const input = Fetch.parseArgv(['users', '--header', 'Authorization: Bearer tok'])
-    expect(input.headers.get('Authorization')).toBe('Bearer tok')
-  })
-
-  test('multiple headers', () => {
-    const input = Fetch.parseArgv(['users', '-H', 'X-A: 1', '-H', 'X-B: 2'])
-    expect(input.headers.get('X-A')).toBe('1')
-    expect(input.headers.get('X-B')).toBe('2')
-  })
-
-  test('unknown --key value → query params', () => {
-    const input = Fetch.parseArgv(['users', '--limit', '5', '--sort', 'name'])
-    expect(input.query.get('limit')).toBe('5')
-    expect(input.query.get('sort')).toBe('name')
-  })
-
-  test('--key=value → query params', () => {
-    const input = Fetch.parseArgv(['users', '--limit=5'])
-    expect(input.query.get('limit')).toBe('5')
-  })
-
-  test('--method as last token throws missing value error', () => {
-    expect(() => Fetch.parseArgv(['users', '--method'])).toThrow('Missing value for --method')
-  })
-
-  test('-X as last token throws missing value error', () => {
-    expect(() => Fetch.parseArgv(['users', '-X'])).toThrow('Missing value for -X')
-  })
-
-  test('--header as last token throws missing value error', () => {
-    expect(() => Fetch.parseArgv(['users', '--header'])).toThrow('Missing value for --header')
-  })
-
-  test('--limit as last token throws missing value error', () => {
-    expect(() => Fetch.parseArgv(['users', '--limit'])).toThrow('Missing value for --limit')
-  })
-
-  test('unknown short flag does not swallow the next token', () => {
-    const input = Fetch.parseArgv(['users', '-z', 'create'])
-    expect(input.path).toBe('/users/create')
-  })
-
-  test('mixed tokens, flags, and query params', () => {
-    const input = Fetch.parseArgv([
-      'users',
-      '42',
-      '--limit',
-      '5',
-      '-X',
-      'POST',
-      '-d',
-      '{"x":1}',
-      '-H',
-      'Auth: tok',
-    ])
-    expect(input.path).toBe('/users/42')
-    expect(input.method).toBe('POST')
-    expect(input.body).toBe('{"x":1}')
-    expect(input.query.get('limit')).toBe('5')
-    expect(input.headers.get('Auth')).toBe('tok')
-  })
-})
-
-describe('buildRequest', () => {
-  test('builds GET request with path', () => {
-    const req = Fetch.buildRequest(Fetch.parseArgv(['users']))
-    expect(req.method).toBe('GET')
-    expect(new URL(req.url).pathname).toBe('/users')
-  })
-
-  test('builds request with query params', () => {
-    const req = Fetch.buildRequest(Fetch.parseArgv(['users', '--limit', '5']))
-    const url = new URL(req.url)
-    expect(url.searchParams.get('limit')).toBe('5')
-  })
-
-  test('builds POST request with body', () => {
-    const req = Fetch.buildRequest(Fetch.parseArgv(['users', '-X', 'POST', '-d', '{"name":"Bob"}']))
-    expect(req.method).toBe('POST')
-  })
-
-  test('builds request with headers', () => {
-    const req = Fetch.buildRequest(Fetch.parseArgv(['users', '-H', 'X-Api-Key: secret']))
-    expect(req.headers.get('X-Api-Key')).toBe('secret')
-  })
-})
-
-describe('parseResponse', () => {
-  test('parses JSON response', async () => {
-    const res = new Response(JSON.stringify({ ok: true }), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    })
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.status).toBe(200)
-    expect(output.data).toEqual({ ok: true })
-  })
-
-  test('parses text response', async () => {
-    const res = new Response('hello world', { status: 200 })
-    const output = await Fetch.parseResponse(res)
-    expect(output.data).toBe('hello world')
-  })
-
-  test('error status → ok: false', async () => {
-    const res = new Response(JSON.stringify({ message: 'not found' }), {
-      status: 404,
-      headers: { 'content-type': 'application/json' },
-    })
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(false)
-    expect(output.status).toBe(404)
-    expect(output.data).toEqual({ message: 'not found' })
-  })
-})
-
-describe('round-trip with Hono', () => {
-  test('GET /users', async () => {
-    const input = Fetch.parseArgv(['users'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toEqual({ users: [{ id: 1, name: 'Alice' }], limit: 10 })
-  })
-
-  test('GET /users?limit=5', async () => {
-    const input = Fetch.parseArgv(['users', '--limit', '5'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toEqual({ users: [{ id: 1, name: 'Alice' }], limit: 5 })
-  })
-
-  test('GET /users/:id', async () => {
-    const input = Fetch.parseArgv(['users', '42'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toEqual({ id: 42, name: 'Alice' })
-  })
-
-  test('POST /users with body', async () => {
-    const input = Fetch.parseArgv(['users', '-X', 'POST', '-d', '{"name":"Bob"}'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.status).toBe(201)
-    expect(output.data).toEqual({ created: true, name: 'Bob' })
-  })
-
-  test('POST /users with implicit method', async () => {
-    const input = Fetch.parseArgv(['users', '--body', '{"name":"Eve"}'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toEqual({ created: true, name: 'Eve' })
-  })
-
-  test('DELETE /users/:id', async () => {
-    const input = Fetch.parseArgv(['users', '1', '--method', 'DELETE'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toEqual({ deleted: true, id: 1 })
-  })
-
-  test('GET /health', async () => {
-    const input = Fetch.parseArgv(['health'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toEqual({ ok: true })
-  })
-
-  test('GET /error → 404', async () => {
-    const input = Fetch.parseArgv(['error'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(false)
-    expect(output.status).toBe(404)
-    expect(output.data).toEqual({ message: 'not found' })
-  })
-
-  test('GET /text → plain text', async () => {
-    const input = Fetch.parseArgv(['text'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-    expect(output.data).toBe('hello world')
-  })
-
-  test('custom headers pass through', async () => {
-    const input = Fetch.parseArgv(['users', '-H', 'X-Custom: hello'])
-    const req = Fetch.buildRequest(input)
-    expect(req.headers.get('X-Custom')).toBe('hello')
-    const res = await app.fetch(req)
-    const output = await Fetch.parseResponse(res)
-    expect(output.ok).toBe(true)
-  })
-
-  test('streaming NDJSON response', async () => {
-    const input = Fetch.parseArgv(['stream'])
-    const req = Fetch.buildRequest(input)
-    const res = await app.fetch(req)
-    expect(Fetch.isStreamingResponse(res)).toBe(true)
-    const chunks: unknown[] = []
-    for await (const chunk of Fetch.parseStreamingResponse(res)) {
-      chunks.push(chunk)
-    }
-    expect(chunks).toEqual([{ progress: 1 }, { progress: 2 }])
-  })
-})

package/node_modules/incur/src/Filter.test.ts

@@ -1,237 +0,0 @@
-import { Filter } from 'incur'
-
-describe('parse', () => {
-  test('single key', () => {
-    expect(Filter.parse('foo')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "foo",
-          },
-        ],
-      ]
-    `)
-  })
-
-  test('dot notation', () => {
-    expect(Filter.parse('bar.baz')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "bar",
-          },
-          {
-            "key": "baz",
-          },
-        ],
-      ]
-    `)
-  })
-
-  test('slice notation', () => {
-    expect(Filter.parse('items[0,3]')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "items",
-          },
-          {
-            "end": 3,
-            "start": 0,
-          },
-        ],
-      ]
-    `)
-  })
-
-  test('mixed keys and slices', () => {
-    expect(Filter.parse('a.b.c[0,10]')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "a",
-          },
-          {
-            "key": "b",
-          },
-          {
-            "key": "c",
-          },
-          {
-            "end": 10,
-            "start": 0,
-          },
-        ],
-      ]
-    `)
-  })
-
-  test('multiple paths', () => {
-    expect(Filter.parse('name,age')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "name",
-          },
-        ],
-        [
-          {
-            "key": "age",
-          },
-        ],
-      ]
-    `)
-  })
-
-  test('slice followed by dot path', () => {
-    expect(Filter.parse('items[0,3].name')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "items",
-          },
-          {
-            "end": 3,
-            "start": 0,
-          },
-          {
-            "key": "name",
-          },
-        ],
-      ]
-    `)
-  })
-
-  test('comma inside slice is not a separator', () => {
-    expect(Filter.parse('foo,items[0,3],bar')).toMatchInlineSnapshot(`
-      [
-        [
-          {
-            "key": "foo",
-          },
-        ],
-        [
-          {
-            "key": "items",
-          },
-          {
-            "end": 3,
-            "start": 0,
-          },
-        ],
-        [
-          {
-            "key": "bar",
-          },
-        ],
-      ]
-    `)
-  })
-})
-
-describe('apply', () => {
-  test('selects single top-level key', () => {
-    const data = { name: 'alice', age: 30, email: 'alice@example.com' }
-    expect(Filter.apply(data, Filter.parse('name'))).toMatchInlineSnapshot(`"alice"`)
-  })
-
-  test('selects nested key with dot notation', () => {
-    const data = { user: { name: 'alice', email: 'alice@example.com' }, status: 'active' }
-    expect(Filter.apply(data, Filter.parse('user.name'))).toMatchInlineSnapshot(`
-      {
-        "user": {
-          "name": "alice",
-        },
-      }
-    `)
-  })
-
-  test('slices array', () => {
-    const data = { items: [1, 2, 3, 4, 5] }
-    expect(Filter.apply(data, Filter.parse('items[0,3]'))).toMatchInlineSnapshot(`
-      {
-        "items": [
-          1,
-          2,
-          3,
-        ],
-      }
-    `)
-  })
-
-  test('selects nested field after slice', () => {
-    const data = {
-      users: [
-        { name: 'alice', age: 30 },
-        { name: 'bob', age: 25 },
-        { name: 'charlie', age: 35 },
-      ],
-    }
-    expect(Filter.apply(data, Filter.parse('users[0,2].name'))).toMatchInlineSnapshot(`
-      {
-        "users": [
-          {
-            "name": "alice",
-          },
-          {
-            "name": "bob",
-          },
-        ],
-      }
-    `)
-  })
-
-  test('multiple filter paths merged', () => {
-    const data = { name: 'alice', age: 30, email: 'alice@example.com' }
-    expect(Filter.apply(data, Filter.parse('name,age'))).toMatchInlineSnapshot(`
-      {
-        "age": 30,
-        "name": "alice",
-      }
-    `)
-  })
-
-  test('returns scalar directly for single key selection', () => {
-    const data = { message: 'hello world', status: 'ok' }
-    const result = Filter.apply(data, Filter.parse('message'))
-    expect(result).toBe('hello world')
-  })
-
-  test('returns object for single key with object value', () => {
-    const data = { user: { name: 'alice' }, status: 'ok' }
-    expect(Filter.apply(data, Filter.parse('user'))).toMatchInlineSnapshot(`
-      {
-        "user": {
-          "name": "alice",
-        },
-      }
-    `)
-  })
-
-  test('returns undefined for missing key', () => {
-    const data = { name: 'alice' }
-    expect(Filter.apply(data, Filter.parse('missing'))).toMatchInlineSnapshot(`undefined`)
-  })
-
-  test('applies filter to each element when data is array', () => {
-    const data = [
-      { name: 'alice', age: 30 },
-      { name: 'bob', age: 25 },
-    ]
-    expect(Filter.apply(data, Filter.parse('name'))).toMatchInlineSnapshot(`
-      [
-        "alice",
-        "bob",
-      ]
-    `)
-  })
-
-  test('empty paths returns data unchanged', () => {
-    const data = { foo: 'bar' }
-    expect(Filter.apply(data, [])).toMatchInlineSnapshot(`
-      {
-        "foo": "bar",
-      }
-    `)
-  })
-})