@astrale-os/adapter-cloudflare 0.1.9 → 0.2.0

package/template/integrations/summary/http.ts

@@ -1,69 +0,0 @@
-/**
- * HTTP summarizer — the REAL external-API adapter: a single OpenAI-compatible
- * `POST /chat/completions` call. This is the shape your domain's external calls
- * take — config + secret from `env`, a timeout via `AbortSignal`, upstream
- * detail preserved in `cause`. Selected by `NOTE_SUMMARIZER=http` (registry.ts);
- * the default stays the no-network `heuristic` adapter so a fresh scaffold needs
- * no secret.
- *
- * `baseUrl` is anything OpenAI-compatible — `https://api.openai.com/v1`, a
- * Workers-AI gateway, or your OWN `ai-gateway` domain's `/v1` surface. On a soft
- * upstream failure it falls back to the heuristic rather than throwing: a flaky
- * summarizer must never block creating a note (see the port contract).
- */
-import { createHeuristicSummarizer } from './heuristic'
-import type { Summarizer } from './port'
-
-export interface HttpSummarizerConfig {
-  /** Bearer token for the upstream (a secret — ships via `.env.<env>`). */
-  apiKey: string
-  /** OpenAI-compatible base URL, e.g. `https://api.openai.com/v1`. */
-  baseUrl: string
-  /** Model id, e.g. `gpt-4o-mini`. */
-  model: string
-  /** Upstream request timeout in ms (default 15000). */
-  timeoutMs?: number
-}
-
-const DEFAULT_TIMEOUT_MS = 15_000
-const SYSTEM_PROMPT = 'Summarize the user note in one short sentence. Reply with the summary only.'
-
-/** Build the OpenAI-compatible HTTP summarizer (with a heuristic fallback). */
-export function createHttpSummarizer(config: HttpSummarizerConfig): Summarizer {
-  const fallback = createHeuristicSummarizer()
-  const endpoint = `${config.baseUrl.replace(/\/+$/, '')}/chat/completions`
-  return {
-    async summarize(body) {
-      try {
-        const res = await fetch(endpoint, {
-          method: 'POST',
-          headers: {
-            'content-type': 'application/json',
-            authorization: `Bearer ${config.apiKey}`,
-          },
-          body: JSON.stringify({
-            model: config.model,
-            messages: [
-              { role: 'system', content: SYSTEM_PROMPT },
-              { role: 'user', content: body },
-            ],
-          }),
-          signal: AbortSignal.timeout(config.timeoutMs ?? DEFAULT_TIMEOUT_MS),
-        })
-        if (!res.ok) {
-          throw new Error(`summarizer upstream returned ${res.status}`, {
-            cause: await res.text().catch(() => undefined),
-          })
-        }
-        const data = (await res.json()) as {
-          choices?: Array<{ message?: { content?: string } }>
-        }
-        const text = data.choices?.[0]?.message?.content?.trim()
-        return text || (await fallback.summarize(body))
-      } catch {
-        // Soft-fail: never block a note create on the summarizer.
-        return fallback.summarize(body)
-      }
-    },
-  }
-}

package/template/integrations/summary/port.ts

@@ -1,21 +0,0 @@
-/**
- * Summarizer — the PORT between the domain's logic and whatever produces a
- * note's one-line summary. This is the external-API seam every real domain has
- * (here: an LLM/summarization API), reduced to the narrowest interface the
- * logic needs.
- *
- * `core/` logic depends on THIS interface only — never on `fetch`, an SDK, or
- * `env`. Adapters in this folder implement it: `heuristic.ts` (the zero-config
- * default, no network) and `http.ts` (a real OpenAI-compatible call). The
- * registry picks one from `env`; the handler logic only ever sees the resolved
- * port. Swap or add a provider = one adapter + one arm in `registry.ts`.
- */
-export interface Summarizer {
-  /**
-   * Produce a short, single-line summary of `body`. Called once per note
-   * create/seed, so keep it fast and resilient. Adapters MUST resolve to a
-   * usable string (fall back to a heuristic rather than throwing on a soft
-   * upstream failure) — a flaky summarizer should never block creating a note.
-   */
-  summarize(body: string): Promise<string>
-}

package/template/integrations/summary/registry.ts

@@ -1,52 +0,0 @@
-/**
- * Summarizer registry — the ONE place the worker env becomes the live
- * `Summarizer` port. Adding a provider = one more arm in `selectSummarizer`;
- * handler logic only ever sees the resolved port.
- *
- * Selection is ON-REQUEST: the provider is chosen + built lazily on the first
- * handler that calls `summarizer()`, then cached for the isolate — NOT at
- * `deps()` construction. A worker left on the default never validates the HTTP
- * provider's env, and a per-request override could slot in here later.
- */
-import type { Env } from '../../env'
-import { createHeuristicSummarizer } from './heuristic'
-import { createHttpSummarizer } from './http'
-import type { Summarizer } from './port'
-
-export interface SummarizerRegistry {
-  /** Resolve the configured summarizer port (lazy + cached per isolate). */
-  summarizer(): Summarizer
-}
-
-/** Build the registry from the worker env (the port is built lazily + cached). */
-export function buildSummarizerRegistry(env: Env): SummarizerRegistry {
-  let cached: Summarizer | undefined
-  return {
-    summarizer() {
-      return (cached ??= selectSummarizer(env))
-    },
-  }
-}
-
-const DEFAULT_HTTP_MODEL = 'gpt-4o-mini'
-
-/** Bind the abstract summarizer port to the configured concrete adapter. */
-function selectSummarizer(env: Env): Summarizer {
-  const provider = (env.NOTE_SUMMARIZER || 'heuristic').toLowerCase()
-
-  if (provider === 'http') {
-    if (!env.SUMMARIZER_API_KEY || !env.SUMMARIZER_BASE_URL) {
-      throw new Error(
-        'NOTE_SUMMARIZER=http requires SUMMARIZER_API_KEY and SUMMARIZER_BASE_URL',
-      )
-    }
-    return createHttpSummarizer({
-      apiKey: env.SUMMARIZER_API_KEY,
-      baseUrl: env.SUMMARIZER_BASE_URL,
-      model: env.SUMMARIZER_MODEL || DEFAULT_HTTP_MODEL,
-    })
-  }
-
-  // Default: the zero-config local heuristic (no network, no secret).
-  return createHeuristicSummarizer()
-}

package/template/schema/note.ts

@@ -1,67 +0,0 @@
-/**
- * Note context — the domain's single bounded slice.
- *
- * One file per context: a class (or a few tightly-related classes) plus the
- * edges that bind them. Here that is the `NoteOps` interface, the `Note`
- * class that implements it, and the `references` edge from one Note to
- * another. To grow the domain, add `schema/<context>.ts` and register its
- * members in `schema/index.ts`.
- *
- *   - Interface `NoteOps`   one static op, `createNote`. Static → the impl
- *                           gets no `self`; it creates a brand-new Note.
- *   - Class `Note`          implements `[NoteOps, Container]`, inheriting
- *                           `createNote` and adding the instance method
- *                           `reference` (links this Note to another).
- *   - Edge `references`     Note → Note. Materialized at runtime by
- *                           `reference` (and by `seed`).
- */
-import { edgeClass, KernelSchema, nodeClass, nodeInterface } from '@astrale-os/kernel-core'
-import { fn } from '@astrale-os/kernel-dsl'
-import { z } from 'zod'
-
-/**
- * Thin ref to a created node — what node-creating ops return. A remote method
- * returns a plain `{ id, path }`, never `ref(SELF)` (whose full-Node value
- * does not round-trip over the worker wire).
- */
-export const NoteRef = z.object({ id: z.string(), path: z.string() })
-
-export const NoteOps = nodeInterface({
-  methods: {
-    createNote: fn({
-      static: true,
-      params: { title: z.string(), body: z.string() },
-      returns: NoteRef,
-    }),
-  },
-})
-
-export const Note = nodeClass({
-  implements: [NoteOps, KernelSchema.interfaces.Container],
-  props: {
-    title: z.string(),
-    body: z.string(),
-    // One-line summary, stamped at create/seed time from the `Summarizer` port
-    // (see integrations/summary/) — the external-API seam wired through `deps`.
-    summary: z.string().optional(),
-  },
-  methods: {
-    reference: fn({
-      params: { target: z.string() },
-      returns: z.object({ linked: z.string() }),
-    }),
-    // Post-install bootstrap (wired as `postInstall` in astrale.config.ts).
-    // Static: the kernel calls it ONCE after install, as __SYSTEM__, with no
-    // `self`. Must stay idempotent — a re-install runs it again.
-    seed: fn({
-      static: true,
-      returns: z.object({ seeded: z.number().int() }),
-    }),
-  },
-})
-
-export const references = edgeClass(
-  { as: 'from_note', types: [Note], cardinality: '0..*' },
-  { as: 'to_note', types: [Note], cardinality: '0..*' },
-  { props: { reason: z.string().optional() } },
-)

package/template/views/note.ts

@@ -1,21 +0,0 @@
-/**
- * `ui-note` — a rich View backed by the `client/` React + Vite SPA (instead of
- * an inline-HTML `render` like `welcome`). Because it declares `mount` rather
- * than `render`, the View node's iframe binding points at `<serving url>/ui/note`
- * — the SDK stamps it from the worker's live URL when it builds the install
- * bundle. The Cloudflare adapter serves `/ui/*` from `../.dist` (built by
- * `client/` with base `/ui/`) via the Worker's `ASSETS` binding.
- *
- * `viewFor: selfOf(Note)` attaches a `view_for` edge to the `Note` class
- * meta-node, so the GUI offers this view for any Note instance.
- */
-import { selfOf } from '@astrale-os/kernel-dsl'
-import { defineView } from '@astrale-os/sdk'
-
-import { Note } from '../schema/note'
-
-export const note = defineView({
-  auth: 'public',
-  mount: '/ui/note',
-  viewFor: selfOf(Note),
-})