@artkit-ai/react 0.1.0 → 0.2.0

package/src/cache.ts

@@ -9,12 +9,9 @@ export interface CacheEntry {
 
 const EMPTY: CacheEntry = Object.freeze({ loading: false }) as CacheEntry;
 
-const keyOf = (id: string, version?: number) => `${id}@${version ?? 'latest'}`;
-
 /**
- * Artifact cache shared by the hooks under one provider (spec §13.2). Versions are immutable, so an
- * entry for a specific version never needs revalidation; the `latest` entry only moves forward and is
- * revalidated on demand. Listeners are per artifact id so history and editors hear about new commits.
+ * Artifact cache shared by the hooks under one provider (spec §13.2). One entry per artifact: the current content the
+ * application last loaded or saved. The library keeps no older versions, so there is nothing else to cache.
  */
 export class ArtifactCache {
   private readonly entries = new Map<string, CacheEntry>();
@@ -23,12 +20,12 @@ export class ArtifactCache {
 
   constructor(private readonly client: ArtifactClient) {}
 
-  entry(id: string, version?: number): CacheEntry {
-    return this.entries.get(keyOf(id, version)) ?? EMPTY;
+  entry(id: string): CacheEntry {
+    return this.entries.get(id) ?? EMPTY;
   }
 
   latest(id: string): Artifact | undefined {
-    return this.entries.get(keyOf(id))?.artifact;
+    return this.entries.get(id)?.artifact;
   }
 
   subscribe(id: string, listener: () => void): () => void {
@@ -45,63 +42,48 @@ export class ArtifactCache {
     for (const listener of [...(this.listeners.get(id) ?? [])]) listener();
   }
 
-  private set(id: string, version: number | undefined, entry: CacheEntry): void {
-    this.entries.set(keyOf(id, version), entry);
-  }
-
   /**
-   * Records a known artifact version (commit result, prop, status change). `latest` only moves forward,
-   * except that a status change on the same version replaces it.
+   * Records an artifact the application loaded or saved. An older version never replaces a newer one; a newer
+   * `updatedAt` of the same version replaces it.
    */
   put(artifact: Artifact): void {
     const current = this.latest(artifact.id);
-    const sameVersionChanged =
-      current !== undefined &&
-      artifact.version === current.version &&
-      (artifact.status !== current.status ||
-        artifact.meta.updatedAt !== current.meta.updatedAt ||
-        artifact.meta.publishedVersion !== current.meta.publishedVersion);
-    const known = this.entries.get(keyOf(artifact.id, artifact.version))?.artifact;
-    if (current && !sameVersionChanged && artifact.version <= current.version && known) return;
-    this.set(artifact.id, artifact.version, { artifact, loading: false });
-    if (!current || artifact.version > current.version || sameVersionChanged) {
-      this.set(artifact.id, undefined, { artifact, loading: false });
+    if (current) {
+      const older = artifact.version < current.version;
+      const sameVersionOlder =
+        artifact.version === current.version && artifact.meta.updatedAt <= current.meta.updatedAt;
+      if (older || sameVersionOlder) return;
     }
+    this.entries.set(artifact.id, { artifact, loading: false });
     this.notify(artifact.id);
   }
 
-  /** Loads unless a fresh value is cached. `force` revalidates `latest` (specific versions never change). */
-  load(id: string, version?: number, force = false): Promise<Artifact> {
-    const key = keyOf(id, version);
-    const existing = this.entries.get(key);
-    if (existing?.artifact && (version !== undefined || !force)) return Promise.resolve(existing.artifact);
-    const pending = this.inflight.get(key);
+  /** Loads the artifact unless it is cached. `force` fetches it again. */
+  load(id: string, force = false): Promise<Artifact> {
+    const existing = this.entries.get(id);
+    if (existing?.artifact && !force) return Promise.resolve(existing.artifact);
+    const pending = this.inflight.get(id);
     if (pending) return pending;
-    this.set(id, version, { ...(existing ?? {}), loading: true });
+    this.entries.set(id, { ...(existing ?? {}), loading: true });
     this.notify(id);
-    const promise = this.client.get(id, version === undefined ? undefined : { version }).then(
+    const promise = this.client.get(id).then(
       (artifact) => {
-        this.inflight.delete(key);
-        if (version === undefined) {
-          // A commit may have landed while the request was in flight; never move `latest` backwards.
-          const current = this.latest(id);
-          if (current && current.version > artifact.version) {
-            this.set(id, undefined, { artifact: current, loading: false });
-            this.notify(id);
-            return current;
-          }
+        this.inflight.delete(id);
+        // A save may have landed while the request was in flight; never move the cache backwards.
+        const current = this.latest(id);
+        if (current && current.version > artifact.version) {
+          this.entries.set(id, { artifact: current, loading: false });
+          this.notify(id);
+          return current;
         }
-        this.set(artifact.id, artifact.version, { artifact, loading: false });
-        if (version === undefined) this.set(id, undefined, { artifact, loading: false });
-        else if (!this.latest(id) || this.latest(id)!.version < artifact.version)
-          this.set(id, undefined, { artifact, loading: false });
+        this.entries.set(id, { artifact, loading: false });
         this.notify(id);
         return artifact;
       },
       (error: unknown) => {
-        this.inflight.delete(key);
-        const previous = this.entries.get(key);
-        this.set(id, version, {
+        this.inflight.delete(id);
+        const previous = this.entries.get(id);
+        this.entries.set(id, {
           ...(previous?.artifact ? { artifact: previous.artifact } : {}),
           error,
           loading: false,
@@ -110,14 +92,9 @@ export class ArtifactCache {
         throw error;
       },
     );
-    this.inflight.set(key, promise);
+    this.inflight.set(id, promise);
     return promise;
   }
-
-  /** Signals listeners of an id without changing entries (e.g. history must refetch after a restore). */
-  touch(id: string): void {
-    this.notify(id);
-  }
 }
 
 const caches = new WeakMap<ArtifactClient, ArtifactCache>();

package/src/client.ts

@@ -14,39 +14,30 @@ import {
   type Lock,
   type Page,
   type PageRequest,
-  type ProjectionMode,
-  type ReadResult,
+  type ReadMode,
+  type ArtifactReadResult as ReadResult,
   type Scope,
-  type VersionEntry,
 } from '@artkit-ai/core';
 
-/** Lifecycle actions accepted by `POST {base}/{id}/status` (spec §15.3). */
-export type StatusAction = 'submit' | 'approve' | 'reject' | 'publish' | 'archive';
-
-export const STATUS_ACTIONS: readonly StatusAction[] = ['submit', 'approve', 'reject', 'publish', 'archive'];
-
 export interface RequestOptions {
   signal?: AbortSignal;
 }
 
 export interface ReadOptions extends RequestOptions {
-  mode?: ProjectionMode;
+  mode?: ReadMode;
   range?: string;
   maxTokens?: number;
   cursor?: string;
-  version?: number;
 }
 
+/** Operations computed against `baseVersion`; a different current version answers VERSION_CONFLICT. */
 export interface ApplyInput {
   baseVersion: number;
   operations: unknown[];
-  idempotencyKey?: string;
-  message?: string;
 }
 
 export interface ExportInput extends RequestOptions {
   format: string;
-  version?: number;
   options?: Record<string, unknown>;
 }
 
@@ -64,14 +55,11 @@ export interface ClientExportResult {
 export interface ArtifactClient {
   list(filter?: ArtifactFilter, page?: PageRequest, options?: RequestOptions): Promise<Page<ArtifactSummary>>;
   create(request: CreateRequest, options?: RequestOptions): Promise<CommitResult>;
-  get(id: string, options?: RequestOptions & { version?: number }): Promise<Artifact>;
+  get(id: string, options?: RequestOptions): Promise<Artifact>;
   read(id: string, options?: ReadOptions): Promise<ReadResult>;
   apply(id: string, input: ApplyInput, options?: RequestOptions): Promise<CommitResult>;
   /** Dry run on the current version: diff and lint without committing. */
   preview(id: string, input: ApplyInput, options?: RequestOptions): Promise<BatchResult>;
-  history(id: string, page?: PageRequest, options?: RequestOptions): Promise<Page<VersionEntry>>;
-  restore(id: string, version: number, message?: string, options?: RequestOptions): Promise<CommitResult>;
-  setStatus(id: string, action: StatusAction, message?: string, options?: RequestOptions): Promise<Artifact>;
   lock(id: string, options?: RequestOptions & { ttlMs?: number }): Promise<Lock>;
   unlock(id: string, lock: Lock, options?: RequestOptions): Promise<void>;
   /** Current lock, or null when nobody holds one. */
@@ -251,7 +239,7 @@ export function createHttpClient(options: HttpClientOptions = {}): ArtifactClien
         opts?.signal,
       ),
     create: (request, opts) => json('POST', path(), request, opts?.signal),
-    get: (id, opts) => json('GET', withQuery(path(id), { version: opts?.version }), undefined, opts?.signal),
+    get: (id, opts) => json('GET', path(id), undefined, opts?.signal),
     read: (id, opts = {}) =>
       json(
         'GET',
@@ -260,24 +248,12 @@ export function createHttpClient(options: HttpClientOptions = {}): ArtifactClien
           range: opts.range,
           maxTokens: opts.maxTokens,
           cursor: opts.cursor,
-          version: opts.version,
         }),
         undefined,
         opts.signal,
       ),
     apply: (id, input, opts) => json('POST', path(id, 'apply'), input, opts?.signal),
     preview: (id, input, opts) => json('POST', path(id, 'preview'), input, opts?.signal),
-    history: (id, page = {}, opts) =>
-      json(
-        'GET',
-        withQuery(path(id, 'history'), { limit: page.limit, cursor: page.cursor }),
-        undefined,
-        opts?.signal,
-      ),
-    restore: (id, version, message, opts) =>
-      json('POST', path(id, 'restore'), { version, ...(message ? { message } : {}) }, opts?.signal),
-    setStatus: (id, action, message, opts) =>
-      json('POST', path(id, 'status'), { action, ...(message ? { message } : {}) }, opts?.signal),
     lock: (id, opts) =>
       json('POST', path(id, 'lock'), opts?.ttlMs === undefined ? {} : { ttlMs: opts.ttlMs }, opts?.signal),
     async unlock(id, lock, opts) {
@@ -290,7 +266,6 @@ export function createHttpClient(options: HttpClientOptions = {}): ArtifactClien
         path(id, 'export'),
         {
           format: input.format,
-          ...(input.version === undefined ? {} : { version: input.version }),
           ...(input.options ? { options: input.options } : {}),
         },
         input.signal,
@@ -337,8 +312,7 @@ export function createServiceClient(service: ArtifactService, scope: Scope | (()
   return {
     list: (filter, page) => run((s) => service.list(s, filter, page)),
     create: (request) => run((s) => service.create(s, request)),
-    get: (id, opts) =>
-      run((s) => service.get(s, id, opts?.version === undefined ? undefined : { version: opts.version })),
+    get: (id) => run((s) => service.get(s, id)),
     read: (id, opts = {}) =>
       run((s) => {
         const { signal: _signal, ...rest } = opts;
@@ -346,27 +320,6 @@ export function createServiceClient(service: ArtifactService, scope: Scope | (()
       }),
     apply: (id, input) => run((s) => service.apply(s, { artifactId: id, ...input })),
     preview: (id, input) => run((s) => service.preview(s, { artifactId: id, ...input })),
-    history: (id, page) => run((s) => service.history(s, id, page)),
-    restore: (id, version, message) => run((s) => service.restore(s, id, version, message)),
-    setStatus: (id, action, message) =>
-      run((s) => {
-        switch (action) {
-          case 'submit':
-            return service.submit(s, id, message);
-          case 'approve':
-            return service.approve(s, id, message);
-          case 'reject':
-            return service.reject(s, id, message);
-          case 'publish':
-            return service.publish(s, id);
-          case 'archive':
-            return service.archive(s, id);
-          default:
-            throw new ArtifactError('INVALID_OPERATION', `Unknown status action "${String(action)}".`, {
-              issues: [{ path: 'action', message: `Use one of: ${STATUS_ACTIONS.join(', ')}.` }],
-            });
-        }
-      }),
     lock: (id, opts) => run((s) => service.lock(s, id, opts?.ttlMs)),
     unlock: (_id, lock) => run((s) => service.unlock(s, lock)),
     getLock: (id) => run((s) => service.getLock(s, id)),
@@ -375,7 +328,6 @@ export function createServiceClient(service: ArtifactService, scope: Scope | (()
         const result = await service.export(s, {
           artifactId: id,
           format: input.format,
-          ...(input.version === undefined ? {} : { version: input.version }),
           ...(input.options ? { options: input.options } : {}),
           ...(input.signal ? { signal: input.signal } : {}),
         });

package/src/components/card.tsx

@@ -3,13 +3,13 @@ import { ArrowUpRight } from 'lucide-react';
 import { type ReactNode, useId } from 'react';
 import { useArtkit } from '../context.js';
 import { KindIcon } from './icons.js';
-import { cx, kindLabel, rootAttributes, type Slots, StatusBadge, slot } from './shared.js';
+import { cx, formatLabel, rootAttributes, type Slots, slot } from './shared.js';
 
 export type ArtifactCardPart = 'body' | 'title' | 'meta' | 'open';
 
 export interface ArtifactCardProps {
   /** Summary or full artifact (only the summary fields are used). */
-  artifact: Pick<ArtifactSummary, 'id' | 'kind' | 'title' | 'version' | 'status'>;
+  artifact: Pick<ArtifactSummary, 'id' | 'format' | 'title' | 'version'>;
   onOpen?(artifact: ArtifactCardProps['artifact']): void;
   /** Render the open action as a link instead of a button. */
   href?: string;
@@ -23,7 +23,7 @@ export interface ArtifactCardProps {
   slots?: Slots<ArtifactCardPart>;
 }
 
-/** Compact card for chat messages: title, kind, version, status and an open action (spec §13.1). */
+/** Compact card for chat messages: title, format, version and an open action (spec §13.1). */
 export function ArtifactCard(props: ArtifactCardProps) {
   const ctx = useArtkit();
   const { t } = ctx;
@@ -35,11 +35,11 @@ export function ArtifactCard(props: ArtifactCardProps) {
       className={cx('ak-root ak-card', props.className)}
       {...rootAttributes(ctx)}
       aria-labelledby={titleId}
-      data-kind={artifact.kind}
+      data-format={artifact.format}
     >
       {props.icon ?? (
         <span className="ak-card-icon">
-          <KindIcon kind={artifact.kind} />
+          <KindIcon format={artifact.format} />
         </span>
       )}
       <div {...slot(props.slots, 'body', 'ak-card-body')}>
@@ -47,12 +47,11 @@ export function ArtifactCard(props: ArtifactCardProps) {
           {artifact.title}
         </h3>
         <div {...slot(props.slots, 'meta', 'ak-card-meta')}>
-          <span>{kindLabel(ctx, artifact.kind)}</span>
+          <span>{formatLabel(ctx, artifact.format)}</span>
           <span>
             <span className="ak-sr-only">{`${t('version')} ${artifact.version}`}</span>
             <span aria-hidden="true">{t('versionShort', { version: artifact.version })}</span>
           </span>
-          <StatusBadge status={artifact.status} />
           {props.streaming ? (
             <span className="ak-badge" data-variant="provisional" role="status">
               {t('generating')}