@pellux/goodvibes-agent 0.1.116 → 1.0.0

package/src/agent/media-generation.ts

@@ -0,0 +1,159 @@
+import type { ArtifactCreateInput, ArtifactDescriptor, ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
+import type {
+  MediaArtifact,
+  MediaGenerationRequest,
+  MediaProvider,
+  MediaProviderRegistry,
+} from '@pellux/goodvibes-sdk/platform/media';
+
+export interface AgentMediaGenerationInput {
+  readonly prompt: string;
+  readonly providerId?: string;
+  readonly modelId?: string;
+  readonly outputMimeType?: string;
+  readonly options?: Record<string, unknown>;
+}
+
+export interface AgentGeneratedMediaArtifact {
+  readonly artifactId: string;
+  readonly mimeType: string;
+  readonly filename?: string;
+  readonly sizeBytes: number;
+  readonly sourceUri?: string;
+}
+
+export interface AgentMediaGenerationResult {
+  readonly providerId: string;
+  readonly artifacts: readonly AgentGeneratedMediaArtifact[];
+  readonly metadata: Record<string, unknown>;
+}
+
+function readText(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function ensurePrompt(prompt: string): string {
+  const trimmed = prompt.trim();
+  if (!trimmed) throw new Error('Media generation prompt is required.');
+  return trimmed;
+}
+
+function findGenerationProvider(registry: MediaProviderRegistry, providerId: string | undefined): MediaProvider {
+  const provider = registry.findProvider('generate', readText(providerId));
+  if (!provider?.generate) {
+    const available = registry
+      .list()
+      .filter((entry) => entry.capabilities.includes('generate'))
+      .map((entry) => entry.id)
+      .join(', ');
+    throw new Error(providerId
+      ? `Media generation provider is unavailable or not configured for generation: ${providerId}.`
+      : `No media generation provider is available${available ? `. Available providers: ${available}` : '.'}`);
+  }
+  return provider;
+}
+
+function filenameForArtifact(artifact: MediaArtifact, index: number): string {
+  if (readText(artifact.filename)) return artifact.filename as string;
+  if (artifact.mimeType.includes('video')) return `agent-generated-${index + 1}.mp4`;
+  if (artifact.mimeType.includes('image')) return `agent-generated-${index + 1}.png`;
+  return `agent-generated-${index + 1}`;
+}
+
+function artifactCreateInput(
+  providerId: string,
+  artifact: MediaArtifact,
+  index: number,
+): ArtifactCreateInput {
+  const filename = filenameForArtifact(artifact, index);
+  const metadata = {
+    ...artifact.metadata,
+    product: 'goodvibes-agent',
+    source: 'agent-media-generation',
+    providerId,
+  };
+  const common = {
+    mimeType: artifact.mimeType,
+    filename,
+    metadata,
+  };
+  if (readText(artifact.dataBase64)) {
+    return {
+      ...common,
+      dataBase64: artifact.dataBase64,
+      sourceUri: artifact.uri,
+      acquisitionMode: 'inline-data',
+    };
+  }
+  if (readText(artifact.uri)) {
+    return {
+      ...common,
+      uri: artifact.uri,
+      sourceUri: artifact.uri,
+      acquisitionMode: 'remote-fetch',
+      fetchMode: 'public-only',
+    };
+  }
+  throw new Error(`Generated media artifact ${index + 1} did not include inline data or a fetchable URI.`);
+}
+
+function toGeneratedArtifact(descriptor: ArtifactDescriptor): AgentGeneratedMediaArtifact {
+  return {
+    artifactId: descriptor.id,
+    mimeType: descriptor.mimeType,
+    ...(descriptor.filename ? { filename: descriptor.filename } : {}),
+    sizeBytes: descriptor.sizeBytes,
+    ...(descriptor.sourceUri ? { sourceUri: descriptor.sourceUri } : {}),
+  };
+}
+
+function buildProviderRequest(input: AgentMediaGenerationInput): MediaGenerationRequest {
+  return {
+    prompt: ensurePrompt(input.prompt),
+    ...(readText(input.outputMimeType) ? { outputMimeType: readText(input.outputMimeType) } : {}),
+    ...(readText(input.modelId) ? { modelId: readText(input.modelId) } : {}),
+    ...(input.options ? { options: input.options } : {}),
+    metadata: {
+      product: 'goodvibes-agent',
+      source: 'agent-media-generation',
+    },
+  };
+}
+
+export async function generateAgentMedia(
+  registry: MediaProviderRegistry,
+  artifactStore: Pick<ArtifactStore, 'create'>,
+  input: AgentMediaGenerationInput,
+): Promise<AgentMediaGenerationResult> {
+  const provider = findGenerationProvider(registry, input.providerId);
+  const generate = provider.generate;
+  if (!generate) throw new Error(`Media generation provider is unavailable or not configured for generation: ${provider.id}.`);
+  const generated = await generate(buildProviderRequest(input));
+  const artifacts: AgentGeneratedMediaArtifact[] = [];
+  for (const [index, artifact] of generated.artifacts.entries()) {
+    const descriptor = await artifactStore.create(artifactCreateInput(generated.providerId, artifact, index));
+    artifacts.push(toGeneratedArtifact(descriptor));
+  }
+  if (artifacts.length === 0) throw new Error(`Media provider ${generated.providerId} did not return artifacts.`);
+  return {
+    providerId: generated.providerId,
+    artifacts,
+    metadata: generated.metadata,
+  };
+}
+
+export function formatAgentMediaGenerationResult(result: AgentMediaGenerationResult): string {
+  return [
+    'Agent media generated',
+    `  provider ${result.providerId}`,
+    `  artifacts ${result.artifacts.length}`,
+    ...result.artifacts.map((artifact, index) => [
+      `  ${index + 1}. ${artifact.artifactId}`,
+      `     type ${artifact.mimeType}`,
+      `     size ${artifact.sizeBytes} bytes`,
+      ...(artifact.filename ? [`     filename ${artifact.filename}`] : []),
+      ...(artifact.sourceUri ? [`     source ${artifact.sourceUri}`] : []),
+    ].join('\n')),
+  ].join('\n');
+}

package/src/agent/memory-prompt.ts

@@ -1,5 +1,4 @@
 import type { MemoryRecord, MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
-
 const DEFAULT_LIMIT = 10;
 export const MIN_PROMPT_MEMORY_CONFIDENCE = 50;
 

package/src/agent/note-registry.ts

@@ -0,0 +1,329 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { assertNoSecretLikeText } from './persona-registry.ts';
+
+export type AgentNoteSource = 'user' | 'agent' | 'imported' | 'system';
+export type AgentNoteReviewState = 'fresh' | 'reviewed' | 'stale';
+
+export interface AgentNoteRecord {
+  readonly id: string;
+  readonly title: string;
+  readonly body: string;
+  readonly tags: readonly string[];
+  readonly sourceUrl?: string;
+  readonly source: AgentNoteSource;
+  readonly provenance: string;
+  readonly reviewState: AgentNoteReviewState;
+  readonly staleReason?: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly reviewedAt?: string;
+}
+
+export interface AgentNoteCreateInput {
+  readonly title: string;
+  readonly body: string;
+  readonly tags?: readonly string[];
+  readonly sourceUrl?: string;
+  readonly source?: AgentNoteSource;
+  readonly provenance?: string;
+}
+
+export interface AgentNoteUpdateInput {
+  readonly title?: string;
+  readonly body?: string;
+  readonly tags?: readonly string[];
+  readonly sourceUrl?: string;
+  readonly provenance?: string;
+}
+
+export interface AgentNoteSnapshot {
+  readonly path: string;
+  readonly notes: readonly AgentNoteRecord[];
+  readonly reviewQueue: readonly AgentNoteRecord[];
+}
+
+interface NoteStoreFile {
+  readonly version: 1;
+  readonly notes: readonly AgentNoteRecord[];
+}
+
+const STORE_VERSION = 1;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readString(value: unknown, fallback = ''): string {
+  return typeof value === 'string' ? value : fallback;
+}
+
+function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function normalizeTitle(title: string): string {
+  return title.trim().replace(/\s+/g, ' ');
+}
+
+function normalizeList(values: readonly string[] | undefined): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values ?? []) {
+    const trimmed = value.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(trimmed);
+  }
+  return result;
+}
+
+function slugify(value: string): string {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return slug || 'note';
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function assertNoNoteSecretLikeText(fields: readonly string[]): void {
+  try {
+    assertNoSecretLikeText(fields);
+  } catch {
+    throw new Error('Notes cannot store secret-looking values. Store a secret reference or remove the sensitive text.');
+  }
+}
+
+function parseNote(value: unknown): AgentNoteRecord | null {
+  if (!isRecord(value)) return null;
+  const id = readString(value.id).trim();
+  const title = normalizeTitle(readString(value.title));
+  const body = readString(value.body).trim();
+  if (!id || !title || !body) return null;
+  const reviewState = value.reviewState === 'reviewed' || value.reviewState === 'stale' ? value.reviewState : 'fresh';
+  const source = value.source === 'agent' || value.source === 'imported' || value.source === 'system' ? value.source : 'user';
+  const sourceUrl = readString(value.sourceUrl).trim();
+  const staleReason = readString(value.staleReason).trim();
+  const reviewedAt = readString(value.reviewedAt).trim();
+  return {
+    id,
+    title,
+    body,
+    tags: readStringArray(value.tags),
+    sourceUrl: sourceUrl || undefined,
+    source,
+    provenance: readString(value.provenance, source).trim() || source,
+    reviewState,
+    staleReason: staleReason || undefined,
+    createdAt: readString(value.createdAt, nowIso()),
+    updatedAt: readString(value.updatedAt, nowIso()),
+    reviewedAt: reviewedAt || undefined,
+  };
+}
+
+function parseStore(raw: string): NoteStoreFile {
+  const parsed: unknown = JSON.parse(raw);
+  if (!isRecord(parsed)) return { version: STORE_VERSION, notes: [] };
+  return {
+    version: STORE_VERSION,
+    notes: Array.isArray(parsed.notes)
+      ? parsed.notes.map(parseNote).filter((entry): entry is AgentNoteRecord => entry !== null)
+      : [],
+  };
+}
+
+function formatStore(store: NoteStoreFile): string {
+  return `${JSON.stringify(store, null, 2)}\n`;
+}
+
+type AgentLocalStorePaths = Pick<ShellPathService, 'resolveUserPath'>;
+
+export function noteStorePath(shellPaths: AgentLocalStorePaths): string {
+  return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'notes', 'notes.json');
+}
+
+export class AgentNoteRegistry {
+  public constructor(private readonly storePath: string) {}
+
+  public static fromShellPaths(shellPaths: AgentLocalStorePaths): AgentNoteRegistry {
+    return new AgentNoteRegistry(noteStorePath(shellPaths));
+  }
+
+  public snapshot(): AgentNoteSnapshot {
+    const store = this.readStore();
+    const notes = [...store.notes].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    return {
+      path: this.storePath,
+      notes,
+      reviewQueue: notes.filter((note) => note.reviewState !== 'reviewed'),
+    };
+  }
+
+  public list(): readonly AgentNoteRecord[] {
+    return this.snapshot().notes;
+  }
+
+  public search(query: string): readonly AgentNoteRecord[] {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) return this.list();
+    return this.list().filter((note) => [
+      note.id,
+      note.title,
+      note.body,
+      note.sourceUrl ?? '',
+      ...note.tags,
+    ].some((field) => field.toLowerCase().includes(normalized)));
+  }
+
+  public get(idOrTitle: string): AgentNoteRecord | null {
+    const lookup = idOrTitle.trim().toLowerCase();
+    if (!lookup) return null;
+    return this.list().find((note) => note.id.toLowerCase() === lookup || note.title.toLowerCase() === lookup) ?? null;
+  }
+
+  public create(input: AgentNoteCreateInput): AgentNoteRecord {
+    const store = this.readStore();
+    const title = normalizeTitle(input.title);
+    const body = input.body.trim();
+    this.validateRequired(title, body);
+    const sourceUrl = input.sourceUrl?.trim() || undefined;
+    assertNoNoteSecretLikeText([title, body, sourceUrl ?? '', ...(input.tags ?? [])]);
+    const duplicate = store.notes.find((note) => note.title.toLowerCase() === title.toLowerCase());
+    if (duplicate) throw new Error(`Note already exists ${duplicate.id}`);
+    const timestamp = nowIso();
+    const note: AgentNoteRecord = {
+      id: this.nextId(title, store.notes),
+      title,
+      body,
+      tags: normalizeList(input.tags),
+      sourceUrl,
+      source: input.source ?? 'user',
+      provenance: input.provenance?.trim() || input.source || 'user',
+      reviewState: 'fresh',
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    };
+    this.writeStore({ ...store, notes: [...store.notes, note] });
+    return note;
+  }
+
+  public update(idOrTitle: string, input: AgentNoteUpdateInput): AgentNoteRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrTitle);
+    if (!existing) throw new Error(`Unknown note ${idOrTitle}`);
+    const title = input.title === undefined ? existing.title : normalizeTitle(input.title);
+    const body = input.body === undefined ? existing.body : input.body.trim();
+    this.validateRequired(title, body);
+    const sourceUrl = input.sourceUrl === undefined ? existing.sourceUrl : input.sourceUrl.trim() || undefined;
+    assertNoNoteSecretLikeText([title, body, sourceUrl ?? '', ...(input.tags ?? [])]);
+    const duplicate = store.notes.find((note) => note.id !== existing.id && note.title.toLowerCase() === title.toLowerCase());
+    if (duplicate) throw new Error(`Note already exists ${duplicate.id}`);
+    const updated: AgentNoteRecord = {
+      ...existing,
+      title,
+      body,
+      tags: input.tags === undefined ? existing.tags : normalizeList(input.tags),
+      sourceUrl,
+      provenance: input.provenance === undefined ? existing.provenance : input.provenance.trim() || existing.provenance,
+      reviewState: 'fresh',
+      staleReason: undefined,
+      reviewedAt: undefined,
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      notes: store.notes.map((note) => note.id === existing.id ? updated : note),
+    });
+    return updated;
+  }
+
+  public markReviewed(idOrTitle: string): AgentNoteRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrTitle);
+    if (!existing) throw new Error(`Unknown note ${idOrTitle}`);
+    const updated: AgentNoteRecord = {
+      ...existing,
+      reviewState: 'reviewed',
+      staleReason: undefined,
+      reviewedAt: nowIso(),
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      notes: store.notes.map((note) => note.id === existing.id ? updated : note),
+    });
+    return updated;
+  }
+
+  public markStale(idOrTitle: string, reason: string): AgentNoteRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrTitle);
+    if (!existing) throw new Error(`Unknown note ${idOrTitle}`);
+    const updated: AgentNoteRecord = {
+      ...existing,
+      reviewState: 'stale',
+      staleReason: reason.trim() || 'Marked stale by user.',
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      notes: store.notes.map((note) => note.id === existing.id ? updated : note),
+    });
+    return updated;
+  }
+
+  public deleteNote(idOrTitle: string): AgentNoteRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrTitle);
+    if (!existing) throw new Error(`Unknown note ${idOrTitle}`);
+    this.writeStore({
+      ...store,
+      notes: store.notes.filter((note) => note.id !== existing.id),
+    });
+    return existing;
+  }
+
+  private validateRequired(title: string, body: string): void {
+    if (!title) throw new Error('Note title is required.');
+    if (!body) throw new Error('Note body is required.');
+  }
+
+  private nextId(title: string, notes: readonly AgentNoteRecord[]): string {
+    const base = slugify(title);
+    const ids = new Set(notes.map((note) => note.id));
+    if (!ids.has(base)) return base;
+    for (let index = 2; index < 1000; index += 1) {
+      const candidate = `${base}-${index}`;
+      if (!ids.has(candidate)) return candidate;
+    }
+    throw new Error(`Could not allocate note id for ${title}.`);
+  }
+
+  private findInStore(store: NoteStoreFile, idOrTitle: string): AgentNoteRecord | null {
+    const lookup = idOrTitle.trim().toLowerCase();
+    if (!lookup) return null;
+    return store.notes.find((note) => note.id.toLowerCase() === lookup || note.title.toLowerCase() === lookup) ?? null;
+  }
+
+  private readStore(): NoteStoreFile {
+    if (!existsSync(this.storePath)) return { version: STORE_VERSION, notes: [] };
+    try {
+      return parseStore(readFileSync(this.storePath, 'utf-8'));
+    } catch (error) {
+      throw new Error(`Could not read Agent note store ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  private writeStore(store: NoteStoreFile): void {
+    mkdirSync(dirname(this.storePath), { recursive: true });
+    const tmpPath = `${this.storePath}.tmp`;
+    writeFileSync(tmpPath, formatStore(store), 'utf-8');
+    renameSync(tmpPath, this.storePath);
+  }
+}