@smthrs/std 0.0.0-stage → 1.0.0-rc.3

package/dist/esm/Explore.d.ts

@@ -0,0 +1,328 @@
+/**
+ * Read-only workspace reconnaissance as a dynamic flow.
+ *
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Registry name for the explore flow.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export declare const name: "explore";
+/**
+ * Model-facing description of the explore flow.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export declare const description = "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+/**
+ * Input accepted by the explore flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly prompt: Schema.String;
+}>;
+/**
+ * Decoded input accepted by the `explore` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output returned by the explore flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly findings: Schema.String;
+}>;
+/**
+ * Decoded output returned by the `explore` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static effect envelope for read-only workspace reconnaissance.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the explore effect declaration for one decoded input.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (_input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Transitive capabilities of the read-only flows available to explore.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: ReadonlyArray<string>;
+/**
+ * Constructs an explore flow, optionally pinned to a model.
+ *
+ * Model selection remains optional so the invoking seat can inject its model.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (options: {
+    readonly model?: string | undefined;
+}) => {
+    readonly name: "explore";
+    readonly description: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly input: Schema.Struct<{
+        readonly prompt: Schema.String;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly findings: Schema.String;
+    }>;
+    readonly model: string | undefined;
+    readonly flows: readonly [{
+        readonly name: "read";
+        readonly description: "Read a text file by 1-based offset and limit. content is RAW file text with no line-number prefixes, so any line of it is an edit anchor as it stands; the numbers are startLine/endLine.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly content: Schema.String;
+            readonly startLine: Schema.Number;
+            readonly endLine: Schema.Number;
+            readonly totalLines: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "ls";
+        readonly description: "List a directory with directories first, trailing /, and locale-independent UTF-16 code-unit ordering; use 1-based offset and limit to page large listings.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+            }>>;
+            readonly total: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "glob";
+        readonly description: "Find files through the Smithers Ripgrep Subset v1 contract.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.NonEmptyString;
+            readonly root: Schema.optional<Schema.String>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly total: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "grep";
+        readonly description: "Search file contents through the Smithers Ripgrep Subset v1 contract. limit counts matches, each carrying its own context and enclosing definition; fixedStrings searches a literal, and one is retried.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.String;
+            readonly root: Schema.optional<Schema.String>;
+            readonly fixedStrings: Schema.optional<Schema.Boolean>;
+            readonly ignoreCase: Schema.optional<Schema.Boolean>;
+            readonly smartCase: Schema.optional<Schema.Boolean>;
+            readonly globs: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly beforeContext: Schema.optional<Schema.Int>;
+            readonly afterContext: Schema.optional<Schema.Int>;
+            readonly context: Schema.optional<Schema.Int>;
+            readonly maxCount: Schema.optional<Schema.Int>;
+            readonly filesWithMatches: Schema.optional<Schema.Boolean>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly symbols: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly matches: Schema.$Array<Schema.Struct<{
+                readonly file: Schema.String;
+                readonly line: Schema.Int;
+                readonly text: Schema.String;
+                readonly before: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly after: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly symbol: Schema.optional<Schema.Struct<{
+                    readonly kind: Schema.String;
+                    readonly name: Schema.String;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+            }>>;
+            readonly files: Schema.$Array<Schema.String>;
+            readonly filesSearched: Schema.Int;
+            readonly skippedBinary: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly retriedAsLiteral: Schema.optional<Schema.Boolean>;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }];
+    readonly prompt: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly capabilities: readonly string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+/**
+ * Default explore declaration with seat-selected model injection.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "explore";
+    readonly description: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly input: Schema.Struct<{
+        readonly prompt: Schema.String;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly findings: Schema.String;
+    }>;
+    readonly model: string | undefined;
+    readonly flows: readonly [{
+        readonly name: "read";
+        readonly description: "Read a text file by 1-based offset and limit. content is RAW file text with no line-number prefixes, so any line of it is an edit anchor as it stands; the numbers are startLine/endLine.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly content: Schema.String;
+            readonly startLine: Schema.Number;
+            readonly endLine: Schema.Number;
+            readonly totalLines: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "ls";
+        readonly description: "List a directory with directories first, trailing /, and locale-independent UTF-16 code-unit ordering; use 1-based offset and limit to page large listings.";
+        readonly input: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly offset: Schema.optional<Schema.Int>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+            }>>;
+            readonly total: Schema.Number;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "glob";
+        readonly description: "Find files through the Smithers Ripgrep Subset v1 contract.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.NonEmptyString;
+            readonly root: Schema.optional<Schema.String>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly total: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }, {
+        readonly name: "grep";
+        readonly description: "Search file contents through the Smithers Ripgrep Subset v1 contract. limit counts matches, each carrying its own context and enclosing definition; fixedStrings searches a literal, and one is retried.";
+        readonly input: Schema.Struct<{
+            readonly pattern: Schema.String;
+            readonly root: Schema.optional<Schema.String>;
+            readonly fixedStrings: Schema.optional<Schema.Boolean>;
+            readonly ignoreCase: Schema.optional<Schema.Boolean>;
+            readonly smartCase: Schema.optional<Schema.Boolean>;
+            readonly globs: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly beforeContext: Schema.optional<Schema.Int>;
+            readonly afterContext: Schema.optional<Schema.Int>;
+            readonly context: Schema.optional<Schema.Int>;
+            readonly maxCount: Schema.optional<Schema.Int>;
+            readonly filesWithMatches: Schema.optional<Schema.Boolean>;
+            readonly hidden: Schema.optional<Schema.Boolean>;
+            readonly symbols: Schema.optional<Schema.Boolean>;
+            readonly noIgnore: Schema.optional<Schema.Boolean>;
+            readonly limit: Schema.optional<Schema.Int>;
+        }>;
+        readonly output: Schema.Struct<{
+            readonly matches: Schema.$Array<Schema.Struct<{
+                readonly file: Schema.String;
+                readonly line: Schema.Int;
+                readonly text: Schema.String;
+                readonly before: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly after: Schema.$Array<Schema.Struct<{
+                    readonly line: Schema.Int;
+                    readonly text: Schema.String;
+                }>>;
+                readonly symbol: Schema.optional<Schema.Struct<{
+                    readonly kind: Schema.String;
+                    readonly name: Schema.String;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+            }>>;
+            readonly files: Schema.$Array<Schema.String>;
+            readonly filesSearched: Schema.Int;
+            readonly skippedBinary: Schema.Int;
+            readonly truncated: Schema.Boolean;
+            readonly retriedAsLiteral: Schema.optional<Schema.Boolean>;
+            readonly notice: Schema.optional<Schema.String>;
+        }>;
+        readonly capabilities: string[];
+        readonly effects: import("@smthrs/plan/Effects").Declaration;
+    }];
+    readonly prompt: "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+    readonly capabilities: readonly string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+//# sourceMappingURL=Explore.d.ts.map

package/dist/esm/Explore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Explore.d.ts","sourceRoot":"","sources":["../../src/Explore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAOvC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAG,SAAkB,CAAA;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,yHACgG,CAAA;AAExH;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;EAIhB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;EAIjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAKlB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,+CAAY,CAAA;AAWhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,aAAa,CAAC,MAAM,CAE9C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,SAAS;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAUU,CAAA;AAEX;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAW,CAAA"}

package/dist/esm/Explore.js

@@ -0,0 +1,106 @@
+/**
+ * Read-only workspace reconnaissance as a dynamic flow.
+ *
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema";
+import * as Glob from "./Glob.js";
+import * as Grep from "./Grep.js";
+import { envelope } from "./internal/Declaration.js";
+import * as Ls from "./Ls.js";
+import * as Read from "./Read.js";
+/**
+ * Registry name for the explore flow.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export const name = "explore";
+/**
+ * Model-facing description of the explore flow.
+ *
+ * @category metadata
+ * @since 1.0.0
+ */
+export const description = "Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.";
+/**
+ * Input accepted by the explore flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export const Input = Schema.Struct({
+    prompt: Schema.String.annotate({
+        description: "The workspace question to investigate."
+    })
+});
+/**
+ * Output returned by the explore flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export const Output = Schema.Struct({
+    findings: Schema.String.annotate({
+        description: "Evidence-backed findings with file:line citations."
+    })
+});
+/**
+ * Static effect envelope for read-only workspace reconnaissance.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export const effects = envelope({
+    tier: "sealed",
+    mode: "hermetic",
+    reads: ["/**"],
+    writes: []
+});
+/**
+ * Narrows the explore effect declaration for one decoded input.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export const effectsFor = (_input) => effects;
+const flows = Object.freeze([
+    Read.flow,
+    Ls.flow,
+    Glob.flow,
+    Grep.flow
+]);
+/**
+ * Transitive capabilities of the read-only flows available to explore.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export const capabilities = Object.freeze([...new Set(flows.flatMap((flow) => flow.capabilities))].sort());
+/**
+ * Constructs an explore flow, optionally pinned to a model.
+ *
+ * Model selection remains optional so the invoking seat can inject its model.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const make = (options) => ({
+    name,
+    description,
+    input: Input,
+    output: Output,
+    model: options.model,
+    flows,
+    prompt: description,
+    capabilities,
+    effects
+});
+/**
+ * Default explore declaration with seat-selected model injection.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export const flow = make({});
+//# sourceMappingURL=Explore.js.map

package/dist/esm/Explore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Explore.js","sourceRoot":"","sources":["../../src/Explore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,SAAS,CAAA;AAC7B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,SAAkB,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GACtB,sHAAsH,CAAA;AAExH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;QAC7B,WAAW,EAAE,wCAAwC;KACtD,CAAC;CACH,CAAC,CAAA;AAUF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;QAC/B,WAAW,EAAE,oDAAoD;KAClE,CAAC;CACH,CAAC,CAAA;AAUF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC;IAC9B,IAAI,EAAE,QAAQ;IACd,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,CAAC,KAAK,CAAC;IACd,MAAM,EAAE,EAAE;CACX,CAAC,CAAA;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAyB,EAAE,EAAE,CAAC,OAAO,CAAA;AAEhE,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CACzB;IACE,IAAI,CAAC,IAAI;IACT,EAAE,CAAC,IAAI;IACP,IAAI,CAAC,IAAI;IACT,IAAI,CAAC,IAAI;CACD,CACX,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,MAAM,CAAC,MAAM,CAC9D,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAChE,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,OAEpB,EAAE,EAAE,CAAC,CAAC;IACL,IAAI;IACJ,WAAW;IACX,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,MAAM;IACd,KAAK,EAAE,OAAO,CAAC,KAAK;IACpB,KAAK;IACL,MAAM,EAAE,WAAW;IACnB,YAAY;IACZ,OAAO;CACE,CAAA,CAAA;AAEX;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,CAAA","sourcesContent":["/**\n * Read-only workspace reconnaissance as a dynamic flow.\n *\n * @since 1.0.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport * as Glob from \"./Glob.ts\"\nimport * as Grep from \"./Grep.ts\"\nimport { envelope } from \"./internal/Declaration.ts\"\nimport * as Ls from \"./Ls.ts\"\nimport * as Read from \"./Read.ts\"\n\n/**\n * Registry name for the explore flow.\n *\n * @category metadata\n * @since 1.0.0\n */\nexport const name = \"explore\" as const\n\n/**\n * Model-facing description of the explore flow.\n *\n * @category metadata\n * @since 1.0.0\n */\nexport const description =\n  \"Investigate the workspace read-only, cite every finding as file:line, report evidence only, and never propose edits.\"\n\n/**\n * Input accepted by the explore flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  prompt: Schema.String.annotate({\n    description: \"The workspace question to investigate.\"\n  })\n})\n\n/**\n * Decoded input accepted by the `explore` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output returned by the explore flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  findings: Schema.String.annotate({\n    description: \"Evidence-backed findings with file:line citations.\"\n  })\n})\n\n/**\n * Decoded output returned by the `explore` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\n/**\n * Static effect envelope for read-only workspace reconnaissance.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({\n  tier: \"sealed\",\n  mode: \"hermetic\",\n  reads: [\"/**\"],\n  writes: []\n})\n\n/**\n * Narrows the explore effect declaration for one decoded input.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (_input: typeof Input.Type) => effects\n\nconst flows = Object.freeze(\n  [\n    Read.flow,\n    Ls.flow,\n    Glob.flow,\n    Grep.flow\n  ] as const\n)\n\n/**\n * Transitive capabilities of the read-only flows available to explore.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities: ReadonlyArray<string> = Object.freeze(\n  [...new Set(flows.flatMap((flow) => flow.capabilities))].sort()\n)\n\n/**\n * Constructs an explore flow, optionally pinned to a model.\n *\n * Model selection remains optional so the invoking seat can inject its model.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (options: {\n  readonly model?: string | undefined\n}) => ({\n  name,\n  description,\n  input: Input,\n  output: Output,\n  model: options.model,\n  flows,\n  prompt: description,\n  capabilities,\n  effects\n} as const)\n\n/**\n * Default explore declaration with seat-selected model injection.\n *\n * @category flows\n * @since 1.0.0\n */\nexport const flow = make({})\n"]}

package/dist/esm/Fetch.d.ts

@@ -0,0 +1,130 @@
+/**
+ * HTTP GET flow declaration and portable handler.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/**
+ * Registry name for the fetch flow.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "fetch";
+/**
+ * Model-facing description of the fetch flow.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const description = "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+/**
+ * Input schema for the fetch flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Input: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly timeout: Schema.optional<Schema.Number>;
+}>;
+/**
+ * Decoded input accepted by the `fetch` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output schema for the fetch flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly status: Schema.Number;
+    readonly body: Schema.String;
+    readonly truncated: Schema.Boolean;
+    readonly notice: Schema.optional<Schema.String>;
+}>;
+/**
+ * Decoded output returned by the `fetch` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Static effect envelope for the fetch flow.
+ *
+ * A retrieval leaves no durable state behind, so it is sealed even though it
+ * leaves the machine.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the fetch effect envelope for one decoded input.
+ *
+ * Network reach is expressed as a capability rather than a path envelope, so
+ * a retrieval has nothing left to narrow.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (_input: typeof Input.Type) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Capabilities required by the fetch flow.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only fetch flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    readonly name: "fetch";
+    readonly description: "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+    readonly input: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly timeout: Schema.optional<Schema.Number>;
+    }>;
+    readonly output: Schema.Struct<{
+        readonly status: Schema.Number;
+        readonly body: Schema.String;
+        readonly truncated: Schema.Boolean;
+        readonly notice: Schema.optional<Schema.String>;
+    }>;
+    readonly capabilities: string[];
+    readonly effects: import("@smthrs/plan/Effects").Declaration;
+};
+/**
+ * Retrieves a URL through the permission-aware kernel HTTP client.
+ *
+ * Error statuses are ordinary results; only transport, permission, and body
+ * decoding failures use the typed error channel.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly url: string;
+    readonly timeout?: number | undefined;
+    readonly headers?: {
+        readonly [x: string]: string;
+    } | undefined;
+}) => Effect.Effect<{
+    readonly status: number;
+    readonly body: string;
+    readonly truncated: boolean;
+    readonly notice?: string | undefined;
+}, import("./StdError.ts").StdError, import("@smthrs/kernel/GrantStore").GrantStore | import("@smthrs/kernel/HttpClient").HttpClient>;
+//# sourceMappingURL=Fetch.d.ts.map

package/dist/esm/Fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fetch.d.ts","sourceRoot":"","sources":["../../src/Fetch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAKvC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,UAAU,CAAA;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,WAAW,kIACyG,CAAA;AAEjI;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;EAQhB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;;EAAW,CAAA;AAE9B;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,4CAAwE,CAAA;AAE5F;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,OAAO,KAAK,CAAC,IAAI,+CAAY,CAAA;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAA+B,CAAA;AAExD;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;qIAAkF,CAAA"}

package/dist/esm/Fetch.js

@@ -0,0 +1,91 @@
+/**
+ * HTTP GET flow declaration and portable handler.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import { capability, envelope } from "./internal/Declaration.js";
+import { execute, Response, Timeout } from "./internal/Http.js";
+/**
+ * Registry name for the fetch flow.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export const name = "fetch";
+/**
+ * Model-facing description of the fetch flow.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export const description = "Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.";
+/**
+ * Input schema for the fetch flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export const Input = Schema.Struct({
+    url: Schema.String.annotate({ description: "Absolute http or https URL to retrieve" }),
+    headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({
+        description: "Additional request headers"
+    }),
+    timeout: Schema.optional(Timeout).annotate({
+        description: "Total request and response body timeout in seconds; defaults to 30, capped at 120"
+    })
+});
+/**
+ * Output schema for the fetch flow.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export const Output = Response;
+/**
+ * Static effect envelope for the fetch flow.
+ *
+ * A retrieval leaves no durable state behind, so it is sealed even though it
+ * leaves the machine.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export const effects = envelope({ tier: "sealed", mode: "expected", reads: [], writes: [] });
+/**
+ * Narrows the fetch effect envelope for one decoded input.
+ *
+ * Network reach is expressed as a capability rather than a path envelope, so
+ * a retrieval has nothing left to narrow.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export const effectsFor = (_input) => effects;
+/**
+ * Capabilities required by the fetch flow.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export const capabilities = [capability("net:get", "*")];
+/**
+ * Declaration-only fetch flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export const flow = { name, description, input: Input, output: Output, capabilities, effects };
+/**
+ * Retrieves a URL through the permission-aware kernel HTTP client.
+ *
+ * Error statuses are ordinary results; only transport, permission, and body
+ * decoding failures use the typed error channel.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export const run = Effect.fn("Fetch.run")((input) => execute(input, HttpClientRequest.get));
+//# sourceMappingURL=Fetch.js.map

package/dist/esm/Fetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fetch.js","sourceRoot":"","sources":["../../src/Fetch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,iBAAiB,MAAM,wCAAwC,CAAA;AAC3E,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,OAAO,CAAA;AAE3B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,WAAW,GACtB,+HAA+H,CAAA;AAEjI;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,WAAW,EAAE,wCAAwC,EAAE,CAAC;IACtF,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC;QAC7E,WAAW,EAAE,4BAA4B;KAC1C,CAAC;IACF,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC;QACzC,WAAW,EAAE,mFAAmF;KACjG,CAAC;CACH,CAAC,CAAA;AAUF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,QAAQ,CAAA;AAU9B;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAA;AAE5F;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAyB,EAAE,EAAE,CAAC,OAAO,CAAA;AAEhE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAA;AAExD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,EAAW,CAAA;AAEvG;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,MAAM,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,KAAY,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,iBAAiB,CAAC,GAAG,CAAC,CAAC,CAAA","sourcesContent":["/**\n * HTTP GET flow declaration and portable handler.\n *\n * @since 1.0.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport * as HttpClientRequest from \"effect/unstable/http/HttpClientRequest\"\nimport { capability, envelope } from \"./internal/Declaration.ts\"\nimport { execute, Response, Timeout } from \"./internal/Http.ts\"\n\n/**\n * Registry name for the fetch flow.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"fetch\"\n\n/**\n * Model-facing description of the fetch flow.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"Get an absolute URL and return its status and text body; long bodies are truncated with a notice. Use http-post to send data.\"\n\n/**\n * Input schema for the fetch flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  url: Schema.String.annotate({ description: \"Absolute http or https URL to retrieve\" }),\n  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)).annotate({\n    description: \"Additional request headers\"\n  }),\n  timeout: Schema.optional(Timeout).annotate({\n    description: \"Total request and response body timeout in seconds; defaults to 30, capped at 120\"\n  })\n})\n\n/**\n * Decoded input accepted by the `fetch` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * Output schema for the fetch flow.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Response\n\n/**\n * Decoded output returned by the `fetch` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\n/**\n * Static effect envelope for the fetch flow.\n *\n * A retrieval leaves no durable state behind, so it is sealed even though it\n * leaves the machine.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({ tier: \"sealed\", mode: \"expected\", reads: [], writes: [] })\n\n/**\n * Narrows the fetch effect envelope for one decoded input.\n *\n * Network reach is expressed as a capability rather than a path envelope, so\n * a retrieval has nothing left to narrow.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (_input: typeof Input.Type) => effects\n\n/**\n * Capabilities required by the fetch flow.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"net:get\", \"*\")]\n\n/**\n * Declaration-only fetch flow.\n *\n * @category flows\n * @since 1.0.0\n */\nexport const flow = { name, description, input: Input, output: Output, capabilities, effects } as const\n\n/**\n * Retrieves a URL through the permission-aware kernel HTTP client.\n *\n * Error statuses are ordinary results; only transport, permission, and body\n * decoding failures use the typed error channel.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"Fetch.run\")((input: Input) => execute(input, HttpClientRequest.get))\n"]}