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

package/dist/cjs/Glob.d.ts

@@ -0,0 +1,204 @@
+/**
+ * The `glob` projection of Smithers Ripgrep Subset v1.
+ *
+ * It has the same two peer implementations as `grep` and supports the
+ * `rg --files -g` pattern subset: `*`, `**`, `?`, and brace alternatives;
+ * results are path sorted; hidden files are opt-in; root and nested .gitignore
+ * files apply by default (even outside git repositories). `noIgnore: true` opts
+ * out. Parent/global ignore files, .git/info/exclude, .ignore and .rgignore
+ * are not read. Caller globs filter the remaining files without overriding
+ * ignores. An explicitly named ignored or skipped directory is still searched.
+ *
+ * **Patterns are relative to `root`, never to the filesystem.** A candidate is
+ * matched by the path it has *relative to the search root*, so `tests/**\/*.py`
+ * — what every caller writing a project-relative pattern means — matches
+ * `<root>/tests/admin_views/admin.py`. Three rules follow, and both peers
+ * implement all three identically:
+ *
+ * - A pattern with no `/` matches the **basename** at any depth: `*.py` finds
+ *   every Python file in the subtree.
+ * - A pattern containing `/` is matched against the root-relative path and is
+ *   anchored at the root: `tests/*.py` matches `<root>/tests/a.py` and not
+ *   `<root>/src/tests/a.py`.
+ * - A leading `/` is the same anchor spelled explicitly, not a filesystem
+ *   absolute path: `/a.py` matches only `<root>/a.py`, where bare `a.py` would
+ *   match any `a.py` in the subtree. A leading `./` means the same anchor.
+ *
+ * `**` crosses directory boundaries, `*` and `?` stay inside one segment, and
+ * `?` consumes one UTF-8 byte. Trailing spaces are not part of a pattern:
+ * `rg` reads `-g` by gitignore's rules and drops them, so `"a.ts "` finds
+ * `a.ts`, and a pattern left blank by that is rejected rather than read as no
+ * filter at all.
+ *
+ * A `root` that names one file is that file. It is reported whatever the
+ * pattern says, because `rg` searches a path given on its command line without
+ * consulting `-g`, and a walk that reaches one file has nothing to filter.
+ *
+ * A walk skips what it cannot read — a dangling symlink, a link cycle, a
+ * directory the process may not list — and reports everything it did reach.
+ * One unreadable entry never fails the call.
+ *
+ * The consequence worth stating is the one that cost a SWE-bench run 41 of its
+ * 43 frames: an *absolute* pattern such as `/home/repo/tests/**` is read as the
+ * root-relative path `home/repo/tests/**`, which nothing under a root of
+ * `/home/repo` can match. That answer is now never silent — a pattern no file
+ * under the root could match reports why through `notice`, so "unsatisfiable"
+ * and "searched and found none" stay distinguishable.
+ *
+ * @since 1.0.0
+ */
+import { Effect, Schema } from "effect";
+import * as Search from "./Search.ts";
+import type * as StdError from "./StdError.ts";
+/**
+ * The registry name for glob.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "glob";
+/**
+ * The model-facing glob description.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const description = "Find files through the Smithers Ripgrep Subset v1 contract.";
+/**
+ * Input accepted by {@link flow} and {@link run}.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const 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>;
+}>;
+/**
+ * Decoded input accepted by the `glob` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * Output produced by {@link run}.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Output: Schema.Struct<{
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly total: Schema.Int;
+    readonly truncated: Schema.Boolean;
+    readonly notice: Schema.optional<Schema.String>;
+}>;
+/**
+ * Decoded output returned by the `glob` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Conservative sealed declaration for all workspace files.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the read declaration to the requested root subtree.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (input: {
+    readonly root?: string | undefined;
+}) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Capability strings requested by glob.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only glob flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    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;
+};
+/**
+ * What a call to this flow does, for a reader of a run.
+ *
+ * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the
+ * governing vocabulary and `StandardFlows` binds this value onto the flow's
+ * descriptor, where the binding site checks it. `declarationDigest` excludes
+ * it, so declaring it cannot invalidate a call identity or a cached prompt.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const activity: "reads";
+/**
+ * How one recorded call to this flow reads: the verb for each settlement, the
+ * input field that is its subject, and the measured output fields a one-line
+ * summary may count.
+ *
+ * Display metadata only, governed by `@smthrs/registry`
+ * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const presentation: {
+    readonly verb: {
+        readonly pending: "listing";
+        readonly success: "listed";
+        readonly failure: "failed to list";
+    };
+    readonly subject: "pattern";
+    readonly result: "paths";
+};
+/**
+ * Runs one `rg --files -g` contract call through the selected peer implementation.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly pattern: string;
+    readonly root?: string | undefined;
+    readonly limit?: number | undefined;
+    readonly hidden?: boolean | undefined;
+    readonly noIgnore?: boolean | undefined;
+}) => Effect.Effect<{
+    readonly paths: readonly string[];
+    readonly truncated: boolean;
+    readonly total: number;
+    readonly notice?: string | undefined;
+}, StdError.StdError, Search.Search>;
+//# sourceMappingURL=Glob.d.ts.map

package/dist/cjs/Glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Glob.d.ts","sourceRoot":"","sources":["../../src/Glob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAGvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,KAAK,QAAQ,MAAM,eAAe,CAAA;AAE9C;;;;;GAKG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;;;;GAKG;AACH,eAAO,MAAM,WAAW,gEAAgE,CAAA;AACxF;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;EAgBhB,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AACrC;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;;EAKjB,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AACvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAA6E,CAAA;AACjG;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,+CAC6B,CAAA;AACrG;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAiC,CAAA;AAC1D;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAG,OAAgB,CAAA;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAIf,CAAA;AAEV;;;;;GAKG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;oCAad,CAAA"}

package/dist/cjs/Glob.js

@@ -0,0 +1,94 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Glob_exports = {};
+__export(Glob_exports, {
+  Input: () => Input,
+  Output: () => Output,
+  activity: () => activity,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  name: () => name,
+  presentation: () => presentation,
+  run: () => run
+});
+module.exports = __toCommonJS(Glob_exports);
+var import_effect = require("effect");
+var import_Declaration = require("./internal/Declaration.js");
+var import_Text = require("./internal/Text.js");
+var Search = __toESM(require("./Search.js"), 1);
+var Contract = __toESM(require("./SearchContract.js"), 1);
+const name = "glob";
+const description = "Find files through the Smithers Ripgrep Subset v1 contract.";
+const Input = import_effect.Schema.Struct({
+  pattern: import_effect.Schema.NonEmptyString.annotate({
+    description: "Ripgrep -g pattern, matched against paths relative to root, never absolute paths: *, ?, {a,b} stay inside one segment, ** crosses directories, a pattern without / matches any basename, and a leading / anchors at root."
+  }),
+  root: import_effect.Schema.optional(import_effect.Schema.String).annotate({
+    description: "Search root the pattern is relative to; defaults to . (the host workspace)."
+  }),
+  hidden: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({ description: "Ripgrep --hidden." }),
+  noIgnore: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({
+    description: "Honor root-scoped .gitignore files by default. Set true to include ignored paths; hidden and fixed directory skips still apply."
+  }),
+  limit: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0))).annotate({
+    description: `Maximum paths, capped at ${import_Text.MAX_ENTRIES}.`
+  })
+});
+const Output = import_effect.Schema.Struct({
+  paths: import_effect.Schema.Array(import_effect.Schema.String),
+  total: import_effect.Schema.Int,
+  truncated: import_effect.Schema.Boolean,
+  notice: import_effect.Schema.optional(import_effect.Schema.String)
+});
+const effects = (0, import_Declaration.envelope)({ tier: "sealed", mode: "hermetic", reads: ["/**"], writes: [] });
+const effectsFor = (input) => (0, import_Declaration.envelope)({ tier: "sealed", mode: "hermetic", reads: [(0, import_Declaration.rootSubtree)(input.root ?? ".")], writes: [] });
+const capabilities = [(0, import_Declaration.capability)("fs:read", "/**")];
+const flow = { name, description, input: Input, output: Output, capabilities, effects };
+const activity = "reads";
+const presentation = {
+  verb: { pending: "listing", success: "listed", failure: "failed to list" },
+  subject: "pattern",
+  result: "paths"
+};
+const run = import_effect.Effect.fn("Glob.run")(function* (input) {
+  const patternError = Contract.validateGlob(input.pattern);
+  if (patternError !== void 0) return yield* import_effect.Effect.fail(patternError);
+  const search = yield* Search.Search;
+  return yield* search.glob({
+    pattern: input.pattern,
+    root: input.root ?? ".",
+    hidden: input.hidden ?? false,
+    noIgnore: input.noIgnore ?? false,
+    limit: Math.min(input.limit ?? import_Text.MAX_ENTRIES, import_Text.MAX_ENTRIES)
+  });
+});
+//# sourceMappingURL=Glob.js.map

package/dist/cjs/Glob.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Glob.ts"],
+  "sourcesContent": ["/**\n * The `glob` projection of Smithers Ripgrep Subset v1.\n *\n * It has the same two peer implementations as `grep` and supports the\n * `rg --files -g` pattern subset: `*`, `**`, `?`, and brace alternatives;\n * results are path sorted; hidden files are opt-in; root and nested .gitignore\n * files apply by default (even outside git repositories). `noIgnore: true` opts\n * out. Parent/global ignore files, .git/info/exclude, .ignore and .rgignore\n * are not read. Caller globs filter the remaining files without overriding\n * ignores. An explicitly named ignored or skipped directory is still searched.\n *\n * **Patterns are relative to `root`, never to the filesystem.** A candidate is\n * matched by the path it has *relative to the search root*, so `tests/**\\/*.py`\n * \u2014 what every caller writing a project-relative pattern means \u2014 matches\n * `<root>/tests/admin_views/admin.py`. Three rules follow, and both peers\n * implement all three identically:\n *\n * - A pattern with no `/` matches the **basename** at any depth: `*.py` finds\n *   every Python file in the subtree.\n * - A pattern containing `/` is matched against the root-relative path and is\n *   anchored at the root: `tests/*.py` matches `<root>/tests/a.py` and not\n *   `<root>/src/tests/a.py`.\n * - A leading `/` is the same anchor spelled explicitly, not a filesystem\n *   absolute path: `/a.py` matches only `<root>/a.py`, where bare `a.py` would\n *   match any `a.py` in the subtree. A leading `./` means the same anchor.\n *\n * `**` crosses directory boundaries, `*` and `?` stay inside one segment, and\n * `?` consumes one UTF-8 byte. Trailing spaces are not part of a pattern:\n * `rg` reads `-g` by gitignore's rules and drops them, so `\"a.ts \"` finds\n * `a.ts`, and a pattern left blank by that is rejected rather than read as no\n * filter at all.\n *\n * A `root` that names one file is that file. It is reported whatever the\n * pattern says, because `rg` searches a path given on its command line without\n * consulting `-g`, and a walk that reaches one file has nothing to filter.\n *\n * A walk skips what it cannot read \u2014 a dangling symlink, a link cycle, a\n * directory the process may not list \u2014 and reports everything it did reach.\n * One unreadable entry never fails the call.\n *\n * The consequence worth stating is the one that cost a SWE-bench run 41 of its\n * 43 frames: an *absolute* pattern such as `/home/repo/tests/**` is read as the\n * root-relative path `home/repo/tests/**`, which nothing under a root of\n * `/home/repo` can match. That answer is now never silent \u2014 a pattern no file\n * under the root could match reports why through `notice`, so \"unsatisfiable\"\n * and \"searched and found none\" stay distinguishable.\n *\n * @since 1.0.0\n */\n\nimport { Effect, Schema } from \"effect\"\nimport { capability, envelope, rootSubtree } from \"./internal/Declaration.ts\"\nimport { MAX_ENTRIES } from \"./internal/Text.ts\"\nimport * as Search from \"./Search.ts\"\nimport * as Contract from \"./SearchContract.ts\"\nimport type * as StdError from \"./StdError.ts\"\n\n/**\n * The registry name for glob.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"glob\"\n/**\n * The model-facing glob description.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description = \"Find files through the Smithers Ripgrep Subset v1 contract.\"\n/**\n * Input accepted by {@link flow} and {@link run}.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Input = Schema.Struct({\n  pattern: Schema.NonEmptyString.annotate({\n    description:\n      \"Ripgrep -g pattern, matched against paths relative to root, never absolute paths: *, ?, {a,b} stay inside one segment, ** crosses directories, a pattern without / matches any basename, and a leading / anchors at root.\"\n  }),\n  root: Schema.optional(Schema.String).annotate({\n    description: \"Search root the pattern is relative to; defaults to . (the host workspace).\"\n  }),\n  hidden: Schema.optional(Schema.Boolean).annotate({ description: \"Ripgrep --hidden.\" }),\n  noIgnore: Schema.optional(Schema.Boolean).annotate({\n    description:\n      \"Honor root-scoped .gitignore files by default. Set true to include ignored paths; hidden and fixed directory skips still apply.\"\n  }),\n  limit: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))).annotate({\n    description: `Maximum paths, capped at ${MAX_ENTRIES}.`\n  })\n})\n/**\n * Decoded input accepted by the `glob` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n/**\n * Output produced by {@link run}.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  paths: Schema.Array(Schema.String),\n  total: Schema.Int,\n  truncated: Schema.Boolean,\n  notice: Schema.optional(Schema.String)\n})\n/**\n * Decoded output returned by the `glob` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n/**\n * Conservative sealed declaration for all workspace files.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effects = envelope({ tier: \"sealed\", mode: \"hermetic\", reads: [\"/**\"], writes: [] })\n/**\n * Narrows the read declaration to the requested root subtree.\n *\n * @category effects\n * @since 1.0.0\n */\nexport const effectsFor = (input: { readonly root?: string | undefined }) =>\n  envelope({ tier: \"sealed\", mode: \"hermetic\", reads: [rootSubtree(input.root ?? \".\")], writes: [] })\n/**\n * Capability strings requested by glob.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"fs:read\", \"/**\")]\n/**\n * Declaration-only glob 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 * What a call to this flow does, for a reader of a run.\n *\n * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the\n * governing vocabulary and `StandardFlows` binds this value onto the flow's\n * descriptor, where the binding site checks it. `declarationDigest` excludes\n * it, so declaring it cannot invalidate a call identity or a cached prompt.\n *\n * @category presentation\n * @since 1.0.0-rc.0\n */\nexport const activity = \"reads\" as const\n\n/**\n * How one recorded call to this flow reads: the verb for each settlement, the\n * input field that is its subject, and the measured output fields a one-line\n * summary may count.\n *\n * Display metadata only, governed by `@smthrs/registry`\n * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.\n *\n * @category presentation\n * @since 1.0.0-rc.0\n */\nexport const presentation = {\n  verb: { pending: \"listing\", success: \"listed\", failure: \"failed to list\" },\n  subject: \"pattern\",\n  result: \"paths\"\n} as const\n\n/**\n * Runs one `rg --files -g` contract call through the selected peer implementation.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"Glob.run\")(function*(\n  input: typeof Input.Type\n): Effect.fn.Return<typeof Output.Type, StdError.StdError, Search.Search> {\n  const patternError = Contract.validateGlob(input.pattern)\n  if (patternError !== undefined) return yield* Effect.fail(patternError)\n  const search = yield* Search.Search\n  return yield* search.glob({\n    pattern: input.pattern,\n    root: input.root ?? \".\",\n    hidden: input.hidden ?? false,\n    noIgnore: input.noIgnore ?? false,\n    limit: Math.min(input.limit ?? MAX_ENTRIES, MAX_ENTRIES)\n  })\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkDA,oBAA+B;AAC/B,yBAAkD;AAClD,kBAA4B;AAC5B,aAAwB;AACxB,eAA0B;AASnB,MAAM,OAAO;AAOb,MAAM,cAAc;AAOpB,MAAM,QAAQ,qBAAO,OAAO;AAAA,EACjC,SAAS,qBAAO,eAAe,SAAS;AAAA,IACtC,aACE;AAAA,EACJ,CAAC;AAAA,EACD,MAAM,qBAAO,SAAS,qBAAO,MAAM,EAAE,SAAS;AAAA,IAC5C,aAAa;AAAA,EACf,CAAC;AAAA,EACD,QAAQ,qBAAO,SAAS,qBAAO,OAAO,EAAE,SAAS,EAAE,aAAa,oBAAoB,CAAC;AAAA,EACrF,UAAU,qBAAO,SAAS,qBAAO,OAAO,EAAE,SAAS;AAAA,IACjD,aACE;AAAA,EACJ,CAAC;AAAA,EACD,OAAO,qBAAO,SAAS,qBAAO,IAAI,MAAM,qBAAO,uBAAuB,CAAC,CAAC,CAAC,EAAE,SAAS;AAAA,IAClF,aAAa,4BAA4B,uBAAW;AAAA,EACtD,CAAC;AACH,CAAC;AAcM,MAAM,SAAS,qBAAO,OAAO;AAAA,EAClC,OAAO,qBAAO,MAAM,qBAAO,MAAM;AAAA,EACjC,OAAO,qBAAO;AAAA,EACd,WAAW,qBAAO;AAAA,EAClB,QAAQ,qBAAO,SAAS,qBAAO,MAAM;AACvC,CAAC;AAcM,MAAM,cAAU,6BAAS,EAAE,MAAM,UAAU,MAAM,YAAY,OAAO,CAAC,KAAK,GAAG,QAAQ,CAAC,EAAE,CAAC;AAOzF,MAAM,aAAa,CAAC,cACzB,6BAAS,EAAE,MAAM,UAAU,MAAM,YAAY,OAAO,KAAC,gCAAY,MAAM,QAAQ,GAAG,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC;AAO7F,MAAM,eAAe,KAAC,+BAAW,WAAW,KAAK,CAAC;AAOlD,MAAM,OAAO,EAAE,MAAM,aAAa,OAAO,OAAO,QAAQ,QAAQ,cAAc,QAAQ;AAatF,MAAM,WAAW;AAajB,MAAM,eAAe;AAAA,EAC1B,MAAM,EAAE,SAAS,WAAW,SAAS,UAAU,SAAS,iBAAiB;AAAA,EACzE,SAAS;AAAA,EACT,QAAQ;AACV;AAQO,MAAM,MAAM,qBAAO,GAAG,UAAU,EAAE,WACvC,OACwE;AACxE,QAAM,eAAe,SAAS,aAAa,MAAM,OAAO;AACxD,MAAI,iBAAiB,OAAW,QAAO,OAAO,qBAAO,KAAK,YAAY;AACtE,QAAM,SAAS,OAAO,OAAO;AAC7B,SAAO,OAAO,OAAO,KAAK;AAAA,IACxB,SAAS,MAAM;AAAA,IACf,MAAM,MAAM,QAAQ;AAAA,IACpB,QAAQ,MAAM,UAAU;AAAA,IACxB,UAAU,MAAM,YAAY;AAAA,IAC5B,OAAO,KAAK,IAAI,MAAM,SAAS,yBAAa,uBAAW;AAAA,EACzD,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/Grep.d.ts

@@ -0,0 +1,347 @@
+/**
+ * The `grep` flow and its Smithers Ripgrep Subset v1 contract.
+ *
+ * Supported ripgrep semantics: Rust-style regular expressions restricted to
+ * Smithers Ripgrep ASCII v1; `-F` (`fixedStrings`); `-i` (`ignoreCase`) and `-S`
+ * (`smartCase`); ordered `-g` include/exclude globs; `-A`, `-B`, and `-C`
+ * context; per-file `--max-count`; `--files-with-matches`; `--hidden`; and
+ * deterministic path/line ordering. Root and nested .gitignore files apply by
+ * default, including outside git repositories. `noIgnore: true` opts out.
+ * Parent/global ignore files, .git/info/exclude, .ignore and .rgignore are not
+ * read. File-type registries are outside v1, and there is no `types` field to
+ * pass. Patterns are capped at 4096 ASCII bytes and counted repetitions at 1000. Invalid UTF-8 is replacement-decoded; NUL-bearing
+ * files are skipped and counted, while an explicitly named binary file is a
+ * typed failure.
+ *
+ * Results are match-centric, which is `rg --json`'s own grouping: `limit`
+ * counts matches, each match carries the context lines that belong to it, and
+ * every context line belongs to exactly one match. A budget that counted rows
+ * could spend itself on context and drop the match — astropy-7166 paid three
+ * frames for exactly that — so a hit is never droppable to make room for its
+ * own surroundings. Truncation is disclosed through `notice`.
+ *
+ * Each returned hit also carries the definition enclosing it when the file's
+ * shape says so plainly, so a read window is computed rather than guessed, and
+ * a metacharacter pattern that finds nothing is retried as a literal with
+ * `retriedAsLiteral` set. Both are properties of the contract rather than of a
+ * peer: they are computed in `internal/Grouping.ts` for both implementations.
+ *
+ * `globs` accepts exactly the shapes `glob` accepts and reads them the same
+ * way: every pattern is matched against each candidate's path *relative to
+ * `root`*, a pattern without `/` matches the basename at any depth, and a
+ * leading `/` or `./` anchors at the root rather than naming a filesystem
+ * absolute path. A `root` that names one file is searched whatever the globs
+ * say. Caller globs filter after ignores; they never override them. See `Glob` for the full statement of the rules. A search that matched
+ * nothing because a positive glob was unsatisfiable says so through `notice`
+ * instead of returning a silent empty result.
+ *
+ * `filesSearched` counts every file the walk and globs admitted, including the binaries
+ * `skippedBinary` reports and any file the process could not open. A walk
+ * skips what it cannot read rather than failing the call.
+ *
+ * Native and in-process implementations are peers behind `Search.Search`.
+ * This module declares and validates the call; it performs no host access.
+ *
+ * @since 1.0.0
+ */
+import { Effect, Schema } from "effect";
+import * as Search from "./Search.ts";
+import * as StdError from "./StdError.ts";
+/**
+ * The registry name for grep.
+ *
+ * @category identifiers
+ * @since 1.0.0
+ */
+export declare const name = "grep";
+/**
+ * The model-facing grep description.
+ *
+ * @category descriptions
+ * @since 1.0.0
+ */
+export declare const 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.";
+/**
+ * Input accepted by {@link flow} and {@link run}.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const 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>;
+}>;
+/**
+ * Decoded input accepted by the `grep` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Input = typeof Input.Type;
+/**
+ * One matching or context line.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const ContextLine: Schema.Struct<{
+    readonly line: Schema.Int;
+    readonly text: Schema.String;
+}>;
+/**
+ * The definition a hit sits inside, when the file's shape says so plainly.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Symbol: Schema.Struct<{
+    readonly kind: Schema.String;
+    readonly name: Schema.String;
+    readonly startLine: Schema.Int;
+    readonly endLine: Schema.Int;
+}>;
+/**
+ * One hit and the context that belongs to it.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const Match: 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;
+    }>>;
+}>;
+/**
+ * Output produced by {@link run}.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const 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>;
+}>;
+/**
+ * Decoded output returned by the `grep` flow.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Output = typeof Output.Type;
+/**
+ * Conservative sealed declaration for all workspace files.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effects: import("@smthrs/plan/Effects").Declaration;
+/**
+ * Narrows the read declaration to the requested root subtree.
+ *
+ * @category effects
+ * @since 1.0.0
+ */
+export declare const effectsFor: (input: {
+    readonly root?: string | undefined;
+}) => import("@smthrs/plan/Effects").Declaration;
+/**
+ * Capability strings requested by grep.
+ *
+ * @category capabilities
+ * @since 1.0.0
+ */
+export declare const capabilities: string[];
+/**
+ * Declaration-only grep flow.
+ *
+ * @category flows
+ * @since 1.0.0
+ */
+export declare const flow: {
+    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;
+};
+/**
+ * What a call to this flow does, for a reader of a run.
+ *
+ * Display metadata only. `@smthrs/registry` `Descriptor.FlowActivity` is the
+ * governing vocabulary and `StandardFlows` binds this value onto the flow's
+ * descriptor, where the binding site checks it. `declarationDigest` excludes
+ * it, so declaring it cannot invalidate a call identity or a cached prompt.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const activity: "reads";
+/**
+ * How one recorded call to this flow reads: the verb for each settlement, the
+ * input field that is its subject, and the measured output fields a one-line
+ * summary may count.
+ *
+ * Display metadata only, governed by `@smthrs/registry`
+ * `Descriptor.CallPresentation` and checked where `StandardFlows` binds it.
+ *
+ * @category presentation
+ * @since 1.0.0-rc.0
+ */
+export declare const presentation: {
+    readonly verb: {
+        readonly pending: "searching";
+        readonly success: "searched";
+        readonly failure: "failed to search";
+    };
+    readonly subject: "pattern";
+    readonly result: "matches";
+};
+/**
+ * Runs one validated ripgrep-contract call through the selected peer implementation.
+ *
+ * A pattern full of metacharacters that finds nothing is the most common way a
+ * search lies: `sphinx-16612` searched 867 files for a parenthesised name and
+ * read `0 of 867` as "this symbol is not used here". The retry costs one more
+ * pass over the same tree only in the case that already found nothing, and the
+ * result says plainly that the answer came from the literal reading.
+ *
+ * @category handlers
+ * @since 1.0.0
+ */
+export declare const run: (input: {
+    readonly pattern: string;
+    readonly root?: string | undefined;
+    readonly limit?: number | undefined;
+    readonly context?: number | undefined;
+    readonly hidden?: boolean | undefined;
+    readonly noIgnore?: boolean | undefined;
+    readonly fixedStrings?: boolean | undefined;
+    readonly ignoreCase?: boolean | undefined;
+    readonly smartCase?: boolean | undefined;
+    readonly globs?: readonly string[] | undefined;
+    readonly beforeContext?: number | undefined;
+    readonly afterContext?: number | undefined;
+    readonly maxCount?: number | undefined;
+    readonly filesWithMatches?: boolean | undefined;
+    readonly symbols?: boolean | undefined;
+}) => Effect.Effect<{
+    readonly truncated: boolean;
+    readonly matches: readonly {
+        readonly line: number;
+        readonly text: string;
+        readonly file: string;
+        readonly after: readonly {
+            readonly line: number;
+            readonly text: string;
+        }[];
+        readonly before: readonly {
+            readonly line: number;
+            readonly text: string;
+        }[];
+        readonly symbol?: {
+            readonly kind: string;
+            readonly name: string;
+            readonly startLine: number;
+            readonly endLine: number;
+        } | undefined;
+    }[];
+    readonly files: readonly string[];
+    readonly filesSearched: number;
+    readonly skippedBinary: number;
+    readonly notice?: string | undefined;
+    readonly retriedAsLiteral?: boolean | undefined;
+}, StdError.StdError, Search.Search>;
+//# sourceMappingURL=Grep.d.ts.map

package/dist/cjs/Grep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Grep.d.ts","sourceRoot":"","sources":["../../src/Grep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B;;;;;GAKG;AACH,eAAO,MAAM,WAAW,6MACoL,CAAA;AAE5M;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;EAkChB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;EAGtB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;;EAOjB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;EAOhB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,4CAA6E,CAAA;AACjG;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,+CAC6B,CAAA;AACrG;;;;;GAKG;AACH,eAAO,MAAM,YAAY,UAAiC,CAAA;AAC1D;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAsF,CAAA;AAEvG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,EAAG,OAAgB,CAAA;AAExC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;;CAIf,CAAA;AA4CV;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAiBd,CAAA"}