@agentskit/doc-bridge 0.1.0-alpha.1 → 0.1.0-alpha.3

package/src/schemas/memory-candidate.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod'
+
+export const MEMORY_CANDIDATE_SCHEMA_VERSION = 1 as const
+
+export const MemorySourceSchema = z.enum([
+  'cursor',
+  'claude',
+  'codex',
+  'copilot',
+  'agent-memory',
+  'manual',
+])
+
+export const MemorySuggestedTypeSchema = z.enum([
+  'user',
+  'feedback',
+  'project',
+  'reference',
+  'unknown',
+])
+
+export const MemoryCandidateV1Schema = z
+  .object({
+    schemaVersion: z.literal(MEMORY_CANDIDATE_SCHEMA_VERSION),
+    id: z.string().min(1).max(256),
+    source: MemorySourceSchema,
+    rawPath: z.string().min(1).max(512).optional(),
+    fact: z.string().min(1).max(8_000),
+    why: z.string().max(4_000).optional(),
+    howToApply: z.string().max(4_000).optional(),
+    suggestedType: MemorySuggestedTypeSchema,
+    confidence: z.number().min(0).max(1),
+    references: z.array(z.string().min(1).max(512)).max(64),
+  })
+  .strict()
+
+export type MemoryCandidateV1 = z.infer<typeof MemoryCandidateV1Schema>

package/src/shims/agentskit-peers.d.ts

@@ -0,0 +1,80 @@
+/** Ambient types for optional Layer-1 peers (not installed with Layer 0). */
+
+declare module '@agentskit/rag' {
+  export type InputDocument = {
+    id?: string
+    content: string
+    source?: string
+    metadata?: Record<string, unknown>
+  }
+  export type RAG = {
+    ingest: (documents: InputDocument[]) => Promise<void>
+    search: (
+      query: string,
+      options?: { topK?: number; threshold?: number },
+    ) => Promise<
+      ReadonlyArray<{
+        id?: string
+        content: string
+        score?: number
+        metadata?: Record<string, unknown>
+        source?: string
+      }>
+    >
+    retrieve: (request: { query: string }) => Promise<unknown[]>
+  }
+  export function createRAG(config: {
+    embed: unknown
+    store: unknown
+    chunkSize?: number
+    chunkOverlap?: number
+    topK?: number
+  }): RAG
+}
+
+declare module '@agentskit/memory' {
+  export function fileVectorMemory(options: { path: string }): unknown
+}
+
+declare module '@agentskit/adapters' {
+  export function ollama(options: { model?: string; baseUrl?: string }): unknown
+  export function openai(options: { apiKey: string; model?: string; baseUrl?: string }): unknown
+  export function anthropic(options: { apiKey: string; model?: string }): unknown
+  export function openrouter(options: { apiKey: string; model?: string }): unknown
+  export function ollamaEmbedder(options?: { model?: string; baseUrl?: string }): unknown
+  export function openaiEmbedder(options: { apiKey: string; model?: string }): unknown
+}
+
+declare module '@agentskit/core' {
+  export function createChatController(config: Record<string, unknown>): {
+    send: (input: string) => Promise<{ content?: string; messages?: unknown[] }>
+    messages?: unknown[]
+  }
+  export function formatRetrievedDocuments(docs: unknown[]): string
+  export function createStaticRetriever(docs: unknown[]): unknown
+}
+
+declare module '@agentskit/ink' {
+  export function useChat(config: Record<string, unknown>): {
+    messages: ReadonlyArray<{ id: string; role: string; content: string }>
+    send: (input: string) => Promise<void>
+    isStreaming?: boolean
+  }
+  export const ChatContainer: unknown
+  export const Message: unknown
+  export const InputBar: unknown
+}
+
+declare module 'ink' {
+  export function render(node: unknown): { unmount: () => void; waitUntilExit: () => Promise<void> }
+}
+
+declare module 'react' {
+  export function createElement(
+    type: unknown,
+    props?: Record<string, unknown> | null,
+    ...children: unknown[]
+  ): unknown
+  const React: { createElement: typeof createElement }
+  export default React
+}

package/src/validate.ts

@@ -0,0 +1,67 @@
+import { ZodError } from 'zod'
+
+import { DocBridgeConfigV1Schema, type DocBridgeConfigV1 } from './config/schema.js'
+import {
+  AgentHandoffLegacySchema,
+  AgentHandoffV1Schema,
+  AgentSearchV1Schema,
+  normalizeAgentHandoff,
+  type AgentHandoffV1,
+  type AgentSearchV1,
+} from './schemas/agent-handoff.js'
+import { DocBridgeIndexV1Schema, type DocBridgeIndexV1 } from './schemas/doc-bridge-index.js'
+import {
+  MemoryCandidateV1Schema,
+  type MemoryCandidateV1,
+} from './schemas/memory-candidate.js'
+
+export type ParseIssue = {
+  readonly path: string
+  readonly message: string
+}
+
+export type ParseResult<T> =
+  | { readonly ok: true; readonly value: T }
+  | { readonly ok: false; readonly issues: readonly ParseIssue[] }
+
+const zodIssues = (error: ZodError): readonly ParseIssue[] =>
+  error.issues.map((issue) => ({
+    path: issue.path.join('.') || '(root)',
+    message: issue.message,
+  }))
+
+export const safeParseAgentHandoff = (input: unknown): ParseResult<AgentHandoffV1> => {
+  const legacy = AgentHandoffLegacySchema.safeParse(input)
+  if (!legacy.success) return { ok: false, issues: zodIssues(legacy.error) }
+  const normalized = AgentHandoffV1Schema.safeParse(normalizeAgentHandoff(legacy.data))
+  if (!normalized.success) return { ok: false, issues: zodIssues(normalized.error) }
+  return { ok: true, value: normalized.data }
+}
+
+export const parseAgentHandoff = (input: unknown): AgentHandoffV1 => {
+  const result = safeParseAgentHandoff(input)
+  if (!result.ok) {
+    throw new Error(
+      `Invalid AgentHandoff:\n${result.issues.map((i) => `  - ${i.path}: ${i.message}`).join('\n')}`,
+    )
+  }
+  return result.value
+}
+
+export const parseAgentSearch = (input: unknown): AgentSearchV1 => AgentSearchV1Schema.parse(input)
+
+export const parseDocBridgeIndex = (input: unknown): DocBridgeIndexV1 =>
+  DocBridgeIndexV1Schema.parse(input)
+
+export const parseMemoryCandidate = (input: unknown): MemoryCandidateV1 =>
+  MemoryCandidateV1Schema.parse(input)
+
+export const parseDocBridgeConfig = (input: unknown): DocBridgeConfigV1 => {
+  const result = DocBridgeConfigV1Schema.safeParse(input)
+  if (!result.success) {
+    throw new Error(
+      `Invalid doc-bridge config:\n${zodIssues(result.error).map((i) => `  - ${i.path}: ${i.message}`).join('\n')}`,
+    )
+  }
+  return result.data
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const PACKAGE_VERSION = '0.1.0-alpha.3'

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "skipLibCheck": true,
+    "ignoreDeprecations": "6.0",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: {
+    index: 'src/index.ts',
+    'config/index': 'src/config/index.ts',
+    'cli/program': 'src/cli/program.ts',
+  },
+  format: ['esm'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  splitting: false,
+  target: 'node22',
+})