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

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"}

package/dist/cjs/Grep.js

@@ -0,0 +1,181 @@
+"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 Grep_exports = {};
+__export(Grep_exports, {
+  ContextLine: () => ContextLine,
+  Input: () => Input,
+  Match: () => Match,
+  Output: () => Output,
+  Symbol: () => Symbol2,
+  activity: () => activity,
+  capabilities: () => capabilities,
+  description: () => description,
+  effects: () => effects,
+  effectsFor: () => effectsFor,
+  flow: () => flow,
+  name: () => name,
+  presentation: () => presentation,
+  run: () => run
+});
+module.exports = __toCommonJS(Grep_exports);
+var import_effect = require("effect");
+var import_Declaration = require("./internal/Declaration.js");
+var import_SearchContract = require("./internal/SearchContract.js");
+var import_Text = require("./internal/Text.js");
+var Search = __toESM(require("./Search.js"), 1);
+var Contract = __toESM(require("./SearchContract.js"), 1);
+var StdError = __toESM(require("./StdError.js"), 1);
+const name = "grep";
+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.";
+const Input = import_effect.Schema.Struct({
+  pattern: import_effect.Schema.String.annotate({ description: "Smithers Ripgrep ASCII v1 expression." }),
+  root: import_effect.Schema.optional(import_effect.Schema.String).annotate({
+    description: "Search root the globs are relative to; defaults to . (the host workspace)."
+  }),
+  fixedStrings: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({ description: "Ripgrep -F." }),
+  ignoreCase: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({ description: "Ripgrep -i." }),
+  smartCase: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({ description: "Ripgrep -S." }),
+  globs: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.String)).annotate({
+    description: "Ordered ripgrep -g globs, matched against paths relative to root, never absolute paths: a glob without / matches any basename, a leading / anchors at root, and ** crosses directories. Prefix exclusions with !."
+  }),
+  beforeContext: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0))).annotate({
+    description: "Ripgrep -B."
+  }),
+  afterContext: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0))).annotate({
+    description: "Ripgrep -A."
+  }),
+  context: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0))).annotate({ description: "Ripgrep -C." }),
+  maxCount: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(1))).annotate({
+    description: "Ripgrep --max-count, per file; at least 1."
+  }),
+  filesWithMatches: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({ description: "Ripgrep --files-with-matches." }),
+  hidden: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({ description: "Ripgrep --hidden." }),
+  symbols: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({
+    description: "Report the definition enclosing each returned hit; true by default."
+  }),
+  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: `Global result limit, capped at ${import_Text.MAX_GREP_MATCHES}.`
+  })
+});
+const ContextLine = import_effect.Schema.Struct({
+  line: import_effect.Schema.Int.annotate({ description: "1-based line number" }),
+  text: import_effect.Schema.String
+});
+const Symbol2 = import_effect.Schema.Struct({
+  kind: import_effect.Schema.String.annotate({ description: "The declaration keyword, such as def or class" }),
+  name: import_effect.Schema.String,
+  startLine: import_effect.Schema.Int.annotate({ description: "1-based first line of the definition" }),
+  endLine: import_effect.Schema.Int.annotate({
+    description: "1-based last line of the definition; read this range, do not guess one"
+  })
+});
+const Match = import_effect.Schema.Struct({
+  file: import_effect.Schema.String,
+  line: import_effect.Schema.Int,
+  text: import_effect.Schema.String,
+  before: import_effect.Schema.Array(ContextLine),
+  after: import_effect.Schema.Array(ContextLine),
+  symbol: import_effect.Schema.optional(Symbol2)
+});
+const Output = import_effect.Schema.Struct({
+  matches: import_effect.Schema.Array(Match),
+  files: import_effect.Schema.Array(import_effect.Schema.String),
+  filesSearched: import_effect.Schema.Int,
+  skippedBinary: import_effect.Schema.Int,
+  truncated: import_effect.Schema.Boolean,
+  retriedAsLiteral: import_effect.Schema.optional(import_effect.Schema.Boolean).annotate({
+    description: "Present when the pattern found nothing as a regex and these results come from re-running it literally"
+  }),
+  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: "searching", success: "searched", failure: "failed to search" },
+  subject: "pattern",
+  result: "matches"
+};
+const normalize = (input) => {
+  if (input.ignoreCase === true && input.smartCase === true) {
+    return (0, import_SearchContract.invalidInput)("-i and -S are mutually exclusive");
+  }
+  if (input.context !== void 0 && (input.beforeContext !== void 0 || input.afterContext !== void 0)) {
+    return (0, import_SearchContract.invalidInput)("-C cannot be combined with -A or -B");
+  }
+  if (input.maxCount !== void 0 && input.maxCount < 1) {
+    return (0, import_SearchContract.invalidInput)("--max-count must be at least 1");
+  }
+  const fixedStrings = input.fixedStrings ?? false;
+  const patternError = Contract.validatePattern(input.pattern, fixedStrings);
+  if (patternError !== void 0) return patternError;
+  for (const glob of input.globs ?? []) {
+    const globError = Contract.validateGlob(glob);
+    if (globError !== void 0) return globError;
+  }
+  return {
+    pattern: input.pattern,
+    root: input.root ?? ".",
+    fixedStrings,
+    ignoreCase: input.ignoreCase ?? false,
+    smartCase: input.smartCase ?? false,
+    globs: input.globs ?? [],
+    beforeContext: input.context ?? input.beforeContext ?? 0,
+    afterContext: input.context ?? input.afterContext ?? 0,
+    maxCount: input.maxCount,
+    filesWithMatches: input.filesWithMatches ?? false,
+    hidden: input.hidden ?? false,
+    noIgnore: input.noIgnore ?? false,
+    symbols: input.symbols ?? true,
+    limit: Math.min(input.limit ?? import_Text.MAX_GREP_MATCHES, import_Text.MAX_GREP_MATCHES)
+  };
+};
+const metacharacters = /[\\^$.|?*+()[\]{}]/;
+const empty = (output) => output.matches.length === 0 && output.files.length === 0;
+const run = import_effect.Effect.fn("Grep.run")(function* (input) {
+  const normalized = normalize(input);
+  if (normalized instanceof StdError.StdError) return yield* import_effect.Effect.fail(normalized);
+  const search = yield* Search.Search;
+  const result = yield* search.grep(normalized);
+  if (normalized.fixedStrings || !empty(result) || !metacharacters.test(normalized.pattern)) return result;
+  const literal = yield* search.grep({ ...normalized, fixedStrings: true });
+  if (empty(literal)) return result;
+  const explanation = `The pattern found nothing as a regular expression and these results come from re-running it literally (fixedStrings: true).`;
+  return {
+    ...literal,
+    retriedAsLiteral: true,
+    notice: literal.notice === void 0 ? explanation : `${explanation} ${literal.notice}`
+  };
+});
+//# sourceMappingURL=Grep.js.map

package/dist/cjs/Grep.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Grep.ts"],
+  "sourcesContent": ["/**\n * The `grep` flow and its Smithers Ripgrep Subset v1 contract.\n *\n * Supported ripgrep semantics: Rust-style regular expressions restricted to\n * Smithers Ripgrep ASCII v1; `-F` (`fixedStrings`); `-i` (`ignoreCase`) and `-S`\n * (`smartCase`); ordered `-g` include/exclude globs; `-A`, `-B`, and `-C`\n * context; per-file `--max-count`; `--files-with-matches`; `--hidden`; and\n * deterministic path/line ordering. Root and nested .gitignore files apply by\n * default, including outside git repositories. `noIgnore: true` opts out.\n * Parent/global ignore files, .git/info/exclude, .ignore and .rgignore are not\n * read. File-type registries are outside v1, and there is no `types` field to\n * pass. Patterns are capped at 4096 ASCII bytes and counted repetitions at 1000. Invalid UTF-8 is replacement-decoded; NUL-bearing\n * files are skipped and counted, while an explicitly named binary file is a\n * typed failure.\n *\n * Results are match-centric, which is `rg --json`'s own grouping: `limit`\n * counts matches, each match carries the context lines that belong to it, and\n * every context line belongs to exactly one match. A budget that counted rows\n * could spend itself on context and drop the match \u2014 astropy-7166 paid three\n * frames for exactly that \u2014 so a hit is never droppable to make room for its\n * own surroundings. Truncation is disclosed through `notice`.\n *\n * Each returned hit also carries the definition enclosing it when the file's\n * shape says so plainly, so a read window is computed rather than guessed, and\n * a metacharacter pattern that finds nothing is retried as a literal with\n * `retriedAsLiteral` set. Both are properties of the contract rather than of a\n * peer: they are computed in `internal/Grouping.ts` for both implementations.\n *\n * `globs` accepts exactly the shapes `glob` accepts and reads them the same\n * way: every pattern is matched against each candidate's path *relative to\n * `root`*, a pattern without `/` matches the basename at any depth, and a\n * leading `/` or `./` anchors at the root rather than naming a filesystem\n * absolute path. A `root` that names one file is searched whatever the globs\n * say. Caller globs filter after ignores; they never override them. See `Glob` for the full statement of the rules. A search that matched\n * nothing because a positive glob was unsatisfiable says so through `notice`\n * instead of returning a silent empty result.\n *\n * `filesSearched` counts every file the walk and globs admitted, including the binaries\n * `skippedBinary` reports and any file the process could not open. A walk\n * skips what it cannot read rather than failing the call.\n *\n * Native and in-process implementations are peers behind `Search.Search`.\n * This module declares and validates the call; it performs no host access.\n *\n * @since 1.0.0\n */\n\nimport { Effect, Schema } from \"effect\"\nimport { capability, envelope, rootSubtree } from \"./internal/Declaration.ts\"\nimport { invalidInput } from \"./internal/SearchContract.ts\"\nimport { MAX_GREP_MATCHES } from \"./internal/Text.ts\"\nimport * as Search from \"./Search.ts\"\nimport * as Contract from \"./SearchContract.ts\"\nimport * as StdError from \"./StdError.ts\"\n\n/**\n * The registry name for grep.\n *\n * @category identifiers\n * @since 1.0.0\n */\nexport const name = \"grep\"\n/**\n * The model-facing grep description.\n *\n * @category descriptions\n * @since 1.0.0\n */\nexport const description =\n  \"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.\"\n\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.String.annotate({ description: \"Smithers Ripgrep ASCII v1 expression.\" }),\n  root: Schema.optional(Schema.String).annotate({\n    description: \"Search root the globs are relative to; defaults to . (the host workspace).\"\n  }),\n  fixedStrings: Schema.optional(Schema.Boolean).annotate({ description: \"Ripgrep -F.\" }),\n  ignoreCase: Schema.optional(Schema.Boolean).annotate({ description: \"Ripgrep -i.\" }),\n  smartCase: Schema.optional(Schema.Boolean).annotate({ description: \"Ripgrep -S.\" }),\n  globs: Schema.optional(Schema.Array(Schema.String)).annotate({\n    description:\n      \"Ordered ripgrep -g globs, matched against paths relative to root, never absolute paths: a glob without / matches any basename, a leading / anchors at root, and ** crosses directories. Prefix exclusions with !.\"\n  }),\n  beforeContext: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))).annotate({\n    description: \"Ripgrep -B.\"\n  }),\n  afterContext: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))).annotate({\n    description: \"Ripgrep -A.\"\n  }),\n  context: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))).annotate({ description: \"Ripgrep -C.\" }),\n  maxCount: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).annotate({\n    description: \"Ripgrep --max-count, per file; at least 1.\"\n  }),\n  filesWithMatches: Schema.optional(Schema.Boolean).annotate({ description: \"Ripgrep --files-with-matches.\" }),\n  hidden: Schema.optional(Schema.Boolean).annotate({ description: \"Ripgrep --hidden.\" }),\n  symbols: Schema.optional(Schema.Boolean).annotate({\n    description: \"Report the definition enclosing each returned hit; true by default.\"\n  }),\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: `Global result limit, capped at ${MAX_GREP_MATCHES}.`\n  })\n})\n\n/**\n * Decoded input accepted by the `grep` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Input = typeof Input.Type\n\n/**\n * One matching or context line.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const ContextLine = Schema.Struct({\n  line: Schema.Int.annotate({ description: \"1-based line number\" }),\n  text: Schema.String\n})\n\n/**\n * The definition a hit sits inside, when the file's shape says so plainly.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Symbol = Schema.Struct({\n  kind: Schema.String.annotate({ description: \"The declaration keyword, such as def or class\" }),\n  name: Schema.String,\n  startLine: Schema.Int.annotate({ description: \"1-based first line of the definition\" }),\n  endLine: Schema.Int.annotate({\n    description: \"1-based last line of the definition; read this range, do not guess one\"\n  })\n})\n\n/**\n * One hit and the context that belongs to it.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Match = Schema.Struct({\n  file: Schema.String,\n  line: Schema.Int,\n  text: Schema.String,\n  before: Schema.Array(ContextLine),\n  after: Schema.Array(ContextLine),\n  symbol: Schema.optional(Symbol)\n})\n\n/**\n * Output produced by {@link run}.\n *\n * @category schemas\n * @since 1.0.0\n */\nexport const Output = Schema.Struct({\n  matches: Schema.Array(Match),\n  files: Schema.Array(Schema.String),\n  filesSearched: Schema.Int,\n  skippedBinary: Schema.Int,\n  truncated: Schema.Boolean,\n  retriedAsLiteral: Schema.optional(Schema.Boolean).annotate({\n    description: \"Present when the pattern found nothing as a regex and these results come from re-running it literally\"\n  }),\n  notice: Schema.optional(Schema.String)\n})\n\n/**\n * Decoded output returned by the `grep` flow.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Output = typeof Output.Type\n\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 grep.\n *\n * @category capabilities\n * @since 1.0.0\n */\nexport const capabilities = [capability(\"fs:read\", \"/**\")]\n/**\n * Declaration-only grep 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: \"searching\", success: \"searched\", failure: \"failed to search\" },\n  subject: \"pattern\",\n  result: \"matches\"\n} as const\n\nconst normalize = (input: typeof Input.Type): Search.GrepInput | StdError.StdError => {\n  if (input.ignoreCase === true && input.smartCase === true) {\n    return invalidInput(\"-i and -S are mutually exclusive\")\n  }\n  if (input.context !== undefined && (input.beforeContext !== undefined || input.afterContext !== undefined)) {\n    return invalidInput(\"-C cannot be combined with -A or -B\")\n  }\n  // `rg --max-count 0` answers nothing at all, not even the summary the native\n  // peer parses, so a cap that admits no match is rejected rather than read\n  // differently by each peer.\n  if (input.maxCount !== undefined && input.maxCount < 1) {\n    return invalidInput(\"--max-count must be at least 1\")\n  }\n  const fixedStrings = input.fixedStrings ?? false\n  const patternError = Contract.validatePattern(input.pattern, fixedStrings)\n  if (patternError !== undefined) return patternError\n  for (const glob of input.globs ?? []) {\n    const globError = Contract.validateGlob(glob)\n    if (globError !== undefined) return globError\n  }\n  return {\n    pattern: input.pattern,\n    root: input.root ?? \".\",\n    fixedStrings,\n    ignoreCase: input.ignoreCase ?? false,\n    smartCase: input.smartCase ?? false,\n    globs: input.globs ?? [],\n    beforeContext: input.context ?? input.beforeContext ?? 0,\n    afterContext: input.context ?? input.afterContext ?? 0,\n    maxCount: input.maxCount,\n    filesWithMatches: input.filesWithMatches ?? false,\n    hidden: input.hidden ?? false,\n    noIgnore: input.noIgnore ?? false,\n    symbols: input.symbols ?? true,\n    limit: Math.min(input.limit ?? MAX_GREP_MATCHES, MAX_GREP_MATCHES)\n  }\n}\n\nconst metacharacters = /[\\\\^$.|?*+()[\\]{}]/\n\nconst empty = (output: typeof Output.Type): boolean => output.matches.length === 0 && output.files.length === 0\n\n/**\n * Runs one validated ripgrep-contract call through the selected peer implementation.\n *\n * A pattern full of metacharacters that finds nothing is the most common way a\n * search lies: `sphinx-16612` searched 867 files for a parenthesised name and\n * read `0 of 867` as \"this symbol is not used here\". The retry costs one more\n * pass over the same tree only in the case that already found nothing, and the\n * result says plainly that the answer came from the literal reading.\n *\n * @category handlers\n * @since 1.0.0\n */\nexport const run = Effect.fn(\"Grep.run\")(function*(\n  input: typeof Input.Type\n): Effect.fn.Return<typeof Output.Type, StdError.StdError, Search.Search> {\n  const normalized = normalize(input)\n  if (normalized instanceof StdError.StdError) return yield* Effect.fail(normalized)\n  const search = yield* Search.Search\n  const result = yield* search.grep(normalized)\n  if (normalized.fixedStrings || !empty(result) || !metacharacters.test(normalized.pattern)) return result\n  const literal = yield* search.grep({ ...normalized, fixedStrings: true })\n  if (empty(literal)) return result\n  const explanation =\n    `The pattern found nothing as a regular expression and these results come from re-running it literally (fixedStrings: true).`\n  return {\n    ...literal,\n    retriedAsLiteral: true,\n    notice: literal.notice === undefined ? explanation : `${explanation} ${literal.notice}`\n  }\n})\n"],
+  "mappings": "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",
+  "names": ["Symbol"]
+}