@kitman-sh/loops 0.0.0-stage → 0.7.0

package/types/packages/core/src/loop-layers.d.ts

@@ -0,0 +1,59 @@
+import type { AgentSandboxNetwork } from './agent-sandbox-policy';
+/** Where a Loop or Agent version lives, nearest first. */
+export declare const LoopLayers: readonly ['project', 'workspace', 'shipped'];
+export type LoopLayer = (typeof LoopLayers)[number];
+export type LayerListings<T> = {
+    readonly [layer in LoopLayer]: readonly T[];
+};
+/** The version an id resolves to: the nearest layer that has it, optionally only below a given layer. */
+export declare const resolveLayered: <T extends {
+    readonly id: string;
+}>(id: string, listings: LayerListings<T>, options?: {
+    readonly below?: LoopLayer;
+}) => {
+    readonly layer: LoopLayer;
+    readonly entry: T;
+} | undefined;
+export declare const AgentEfforts: readonly ['low', 'medium', 'high', 'xhigh'];
+export type AgentEffort = (typeof AgentEfforts)[number];
+/** Whether a harness has an effort control; a StepAttempt on any other harness records its effort as ignored. */
+export declare const harnessTakesEffort: (harness: string) => boolean;
+/** The fields an Agent version may name; one that extends another replaces these, and merges instructions by section. */
+export type AgentFields = {
+    readonly instructions?: string;
+    readonly harness?: string;
+    readonly model?: string;
+    readonly effort?: AgentEffort;
+    readonly kits?: readonly string[];
+    readonly network?: AgentSandboxNetwork;
+    /** The SandboxBackend its Steps require. */
+    readonly sandbox?: 'docker';
+};
+export type AgentListing = AgentFields & {
+    readonly id: string;
+    readonly extends?: string;
+    /** The Package that declares it. */
+    readonly package?: string;
+};
+export type ResolvedAgent = AgentFields & {
+    readonly id: string;
+};
+export type AgentFieldLayers = {
+    readonly [field in keyof AgentFields]?: LoopLayer;
+};
+/**
+ * Merges an extending Agent's instructions into its parent's by `## ` heading: a named section replaces the parent's,
+ * a new one is appended, and text before the first heading replaces the parent's.
+ */
+export declare const mergeAgentInstructions: (parent: string, child: string) => string;
+/**
+ * Resolves an Agent and the chain it extends into one Agent. An Agent that extends its own id extends the version
+ * below its layer, as a fork does.
+ */
+export declare const resolveAgent: (id: string, listings: LayerListings<AgentListing>, options?: {
+    readonly below?: LoopLayer;
+}, seen?: ReadonlySet<string>) => {
+    readonly layer: LoopLayer;
+    readonly agent: ResolvedAgent;
+    readonly fieldLayers: AgentFieldLayers;
+} | undefined;

package/types/packages/core/src/loop-version.d.ts

@@ -0,0 +1,59 @@
+import * as Schema from 'effect/Schema';
+import type { ActorType } from './common';
+import type { LoopStatus } from './loop';
+export declare const LoopVersionStatuses: readonly ['draft', 'published', 'deprecated', 'disabled', 'archived'];
+export type LoopVersionStatus = (typeof LoopVersionStatuses)[number];
+export interface LoopIdentity {
+    readonly id: string;
+    readonly workspaceId: string;
+    readonly projectId?: string;
+    readonly slug: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly status: LoopStatus;
+    readonly createdByActorType: ActorType;
+    readonly createdByActorId: string;
+    readonly delegatedByUserId?: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+/** A portable selector. Admission always resolves this to an immutable version pin. */
+export declare const LoopReferenceSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly loopId: Schema.String;
+    readonly alias: Schema.String;
+}>, Schema.Struct<{
+    readonly loopId: Schema.String;
+    readonly versionId: Schema.String;
+}>, Schema.Struct<{
+    readonly loopId: Schema.String;
+    readonly version: Schema.Int;
+}>, Schema.Struct<{
+    readonly loopId: Schema.String;
+    readonly digest: Schema.String;
+}>, Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly alias: Schema.String;
+}>, Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly version: Schema.Int;
+}>, Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly digest: Schema.String;
+}>]>;
+export type LoopReference = (typeof LoopReferenceSchema)['Type'];
+/** A Loop reference resolved to its exact published version. */
+export interface LoopResolution {
+    readonly loop: LoopIdentity;
+    readonly version: {
+        readonly id: string;
+        readonly version: number;
+        readonly definitionDigest: string;
+    };
+}
+/**
+ * RFC 8785-compatible for the JSON value subset used by Loop definitions.
+ * Object keys are sorted lexicographically and arrays preserve semantic order.
+ */
+export declare function canonicalJson<ValueType>(value: ValueType): string;
+/** SHA-256 over canonical JSON without introducing a Node-only dependency in @kitman/core. */
+export declare function canonicalSha256<ValueType>(value: ValueType): string;