@xandreed/core 0.12.0 → 0.14.0

package/dist/ports/conversation-store.port.d.ts

@@ -1,127 +0,0 @@
-import { Context, Option, Schema } from "effect";
-import type { Effect } from "effect";
-import { AgentMessage, ConversationId } from "../domain/message.entity.js";
-import type { Checkpoint } from "../domain/message.entity.js";
-declare const StoreError_base: Schema.Class<StoreError, Schema.TaggedStruct<"StoreError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class StoreError extends StoreError_base {
-}
-declare const RunOutcomeRecord_base: Schema.Class<RunOutcomeRecord, Schema.Struct<{
-    readonly conversationId: Schema.brand<Schema.String, "ConversationId">;
-    /** Epoch millis. */
-    readonly at: Schema.Number;
-    readonly outcome: Schema.Literals<readonly ["ok", "partial"]>;
-    readonly reason: Schema.Literals<readonly ["completed", "step-cap", "degenerate-loop"]>;
-}>, {}>;
-/** How a run ENDED — persisted beside the trail so the database alone says
- *  whether the last run completed on its own or was stopped by the step cap
- *  or the degenerate-loop breaker (the loop's `agent_end` was in-memory only). */
-export declare class RunOutcomeRecord extends RunOutcomeRecord_base {
-}
-declare const ConversationSummary_base: Schema.Class<ConversationSummary, Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "ConversationId">;
-    readonly createdAt: Schema.Number;
-    readonly firstPrompt: Schema.OptionFromOptional<Schema.String>;
-    readonly title: Schema.OptionFromOptional<Schema.String>;
-    /** The latest recorded run outcome, when a run has finished in it. */
-    readonly lastOutcome: Schema.OptionFromOptional<Schema.Struct<{
-        readonly outcome: Schema.Literals<readonly ["ok", "partial"]>;
-        readonly reason: Schema.Literals<readonly ["completed", "step-cap", "degenerate-loop"]>;
-    }>>;
-}>, {}>;
-export declare class ConversationSummary extends ConversationSummary_base {
-}
-declare const StoredMessage_base: Schema.Class<StoredMessage, Schema.Struct<{
-    readonly position: Schema.Int;
-    readonly message: Schema.Union<readonly [Schema.Struct<{
-        readonly role: Schema.Literal<"user">;
-        readonly content: Schema.String;
-        readonly providerOptions: Schema.optional<Schema.Unknown>;
-    }>, Schema.Struct<{
-        readonly role: Schema.Literal<"assistant">;
-        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly text: Schema.String;
-            readonly providerOptions: Schema.optional<Schema.Unknown>;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"reasoning">;
-            readonly text: Schema.String;
-            readonly providerOptions: Schema.optional<Schema.Unknown>;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"tool-call">;
-            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
-            readonly toolName: Schema.String;
-            readonly input: Schema.Unknown;
-            readonly providerOptions: Schema.optional<Schema.Unknown>;
-            readonly providerExecuted: Schema.optional<Schema.Boolean>;
-        }>]>>;
-        readonly providerOptions: Schema.optional<Schema.Unknown>;
-    }>, Schema.Struct<{
-        readonly role: Schema.Literal<"tool">;
-        readonly content: Schema.$Array<Schema.Struct<{
-            readonly type: Schema.Literal<"tool-result">;
-            readonly toolCallId: Schema.brand<Schema.String, "ToolCallId">;
-            readonly toolName: Schema.String;
-            readonly output: Schema.Unknown;
-            readonly providerOptions: Schema.optional<Schema.Unknown>;
-            readonly isError: Schema.optional<Schema.Boolean>;
-        }>>;
-        readonly providerOptions: Schema.optional<Schema.Unknown>;
-    }>]>;
-}>, {}>;
-/** A persisted row WITH its durable position — what the active window is
- *  made of, so a loader never reconstructs positions by arithmetic (an
- *  undecodable row in between would shift every later one). */
-export declare class StoredMessage extends StoredMessage_base {
-}
-declare const ConversationStore_base: Context.ServiceClass<ConversationStore, "@xandreed/core/ConversationStore", {
-    readonly create: (workspaceDir?: string) => Effect.Effect<ConversationId, StoreError>;
-    readonly append: (id: ConversationId, message: AgentMessage) => Effect.Effect<number, StoreError>;
-    /** One turn's rows land TOGETHER or not at all — an assistant tool call
-     *  without its results is a row the next run cannot send. Returns the
-     *  positions, aligned with the input. */
-    readonly appendAll: (id: ConversationId, messages: ReadonlyArray<AgentMessage>) => Effect.Effect<ReadonlyArray<number>, StoreError>;
-    readonly list: (id: ConversationId) => Effect.Effect<ReadonlyArray<AgentMessage>, StoreError>;
-    /** The rows after the latest fold, each with its position. */
-    readonly listActive: (id: ConversationId) => Effect.Effect<ReadonlyArray<StoredMessage>, StoreError>;
-    readonly checkpoint: (id: ConversationId, summary: string) => Effect.Effect<void, StoreError>;
-    /** A fold up to an EXPLICIT position (the within-run compaction seam):
-     *  rows at or before it are covered by the summary; `listActive` returns
-     *  only the rows after. `checkpoint` folds everything appended so far. */
-    readonly checkpointAt: (id: ConversationId, summary: string, messagePosition: number) => Effect.Effect<void, StoreError>;
-    readonly latestCheckpoint: (id: ConversationId) => Effect.Effect<Option.Option<Checkpoint>, StoreError>;
-    readonly setTitle: (id: ConversationId, title: string) => Effect.Effect<void, StoreError>;
-    /** Record how a run ended (appended; the latest is the conversation's). */
-    readonly recordOutcome: (id: ConversationId, outcome: RunOutcomeRecord["outcome"], reason: RunOutcomeRecord["reason"]) => Effect.Effect<void, StoreError>;
-    readonly latestOutcome: (id: ConversationId) => Effect.Effect<Option.Option<RunOutcomeRecord>, StoreError>;
-    readonly listByWorkspace: (workspaceDir: string) => Effect.Effect<ReadonlyArray<ConversationSummary>, StoreError>;
-    /** BRANCH: copy rows [0..upToPosition] (default: all) into a NEW
-     *  conversation in the same workspace, along with the latest covered
-     *  checkpoint — the original stays untouched; the fork continues
-     *  independently (git-branch semantics over the trail). */
-    readonly fork: (id: ConversationId, upToPosition?: number) => Effect.Effect<ConversationId, StoreError>;
-    /** RETENTION: delete whole conversations created before `beforeEpochMs`
-     *  (messages + checkpoints + the conversation row) and reclaim the
-     *  space. Nothing calls this automatically — deletion is a deliberate,
-     *  human-initiated act on an otherwise append-only store. Returns the
-     *  number of conversations removed. */
-    readonly prune: (beforeEpochMs: number) => Effect.Effect<number, StoreError>;
-}>;
-/**
- * @deprecated Positional compatibility projection over SessionLog. New composable
- * hosts use Sessions, TurnWriter and ConversationMemory directly.
- *
- * The conversation persistence port. Positions are the durable identity:
- * `append` assigns a monotonic, immutable absolute position per conversation,
- * and UIs key their blocks on it so a live-streamed block and a later
- * re-projection of the same message reconcile instead of duplicating.
- *
- * A checkpoint FOLDS the history for loading purposes only: `list` always
- * returns every row; `listActive` returns the rows after the latest fold.
- * The loop prepends the fold's summary itself (domain logic stays here,
- * not in the adapter).
- */
-export declare class ConversationStore extends ConversationStore_base {
-}
-export {};

package/dist/ports/conversation-store.port.js

@@ -1,36 +0,0 @@
-import { Context, Option, Schema } from "effect";
-import { AgentMessage, ConversationId } from "../domain/message.entity.js";
-
-export class StoreError extends Schema.TaggedError()("StoreError", {
-  message: Schema.String
-}) {
-}
-
-export class RunOutcomeRecord extends Schema.Class("RunOutcomeRecord")({
-  conversationId: ConversationId,
-  at: Schema.Number,
-  outcome: Schema.Literals(["ok", "partial"]),
-  reason: Schema.Literals(["completed", "step-cap", "degenerate-loop"])
-}) {
-}
-
-export class ConversationSummary extends Schema.Class("ConversationSummary")({
-  id: ConversationId,
-  createdAt: Schema.Number,
-  firstPrompt: Schema.OptionFromOptional(Schema.String),
-  title: Schema.OptionFromOptional(Schema.String),
-  lastOutcome: Schema.OptionFromOptional(Schema.Struct({
-    outcome: Schema.Literals(["ok", "partial"]),
-    reason: Schema.Literals(["completed", "step-cap", "degenerate-loop"])
-  }))
-}) {
-}
-
-export class StoredMessage extends Schema.Class("StoredMessage")({
-  position: Schema.Int,
-  message: AgentMessage
-}) {
-}
-
-export class ConversationStore extends Context.Service()("@xandreed/core/ConversationStore") {
-}

package/dist/ports/shell.port.d.ts

@@ -1,32 +0,0 @@
-import { Context, Schema } from "effect";
-import type { Effect } from "effect";
-declare const ShellError_base: Schema.Class<ShellError, Schema.TaggedStruct<"ShellError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ShellError extends ShellError_base {
-}
-declare const ShellResult_base: Schema.Class<ShellResult, Schema.Struct<{
-    readonly stdout: Schema.String;
-    readonly stderr: Schema.String;
-    readonly exitCode: Schema.Number;
-}>, {}>;
-export declare class ShellResult extends ShellResult_base {
-}
-declare const Shell_base: Context.ServiceClass<Shell, "@xandreed/core/Shell", {
-    readonly exec: (command: string, options?: {
-        readonly cwd?: string;
-        readonly timeoutMs?: number;
-        /** BEST-EFFORT live tap: called with each output chunk (stdout and
-         *  stderr) as it arrives, so a long build stops looking dead. Sync
-         *  and advisory — the settled `ShellResult` stays the contract. */
-        readonly onChunk?: (chunk: string) => void;
-    }) => Effect.Effect<ShellResult, ShellError>;
-}>;
-/**
- * Subprocess execution. A non-zero exit is a RESULT (the model reads the
- * code + stderr and adapts), never an error — the error channel carries only
- * spawn/timeout infrastructure failures.
- */
-export declare class Shell extends Shell_base {
-}
-export {};

package/dist/ports/shell.port.js

@@ -1,16 +0,0 @@
-import { Context, Schema } from "effect";
-
-export class ShellError extends Schema.TaggedError()("ShellError", {
-  message: Schema.String
-}) {
-}
-
-export class ShellResult extends Schema.Class("ShellResult")({
-  stdout: Schema.String,
-  stderr: Schema.String,
-  exitCode: Schema.Number
-}) {
-}
-
-export class Shell extends Context.Service()("@xandreed/core/Shell") {
-}