@warlock.js/ai-workspace 4.5.0

package/esm/contracts/workspace.contract.d.mts

@@ -0,0 +1,131 @@
+import { EditFileInput, EditFileResult, GrepResult, RunShellResult, WorkspaceToolName } from "./tool-io.type.mjs";
+import { WorkspacePolicy } from "./workspace-policy.type.mjs";
+import { ToolContract } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-workspace/src/contracts/workspace.contract.d.ts
+/**
+ * The agent-facing tool surface of a workspace. Each factory returns a
+ * {@link ToolContract} ready to hand to `ai.agent({ tools })`. `all()`
+ * vends every tool; `pick(...)` selects a least-privilege subset (e.g.
+ * `pick("readFile", "grep", "glob")` for a read-only reviewer).
+ *
+ * Every factory takes an optional `{ name }` so the same workspace can
+ * expose the same capability under a custom tool name when wiring
+ * multiple agents.
+ */
+interface WorkspaceTools {
+  /** All seven tools as `ToolContract[]`, ready for `ai.agent({ tools })`. */
+  all(): ToolContract[];
+  /** A named subset, e.g. `pick("readFile", "grep")` for least privilege. */
+  pick(...names: WorkspaceToolName[]): ToolContract[];
+  /** The `read_file` tool. */
+  readFile(opts?: {
+    name?: string;
+  }): ToolContract;
+  /** The `edit_file` tool (exact-string replace + stale-hash guard). */
+  editFile(opts?: {
+    name?: string;
+  }): ToolContract;
+  /** The `write_file` tool (atomic full-content write). */
+  writeFile(opts?: {
+    name?: string;
+  }): ToolContract;
+  /** The `run_shell` tool (policy-gated command execution). */
+  runShell(opts?: {
+    name?: string;
+  }): ToolContract;
+  /** The `run_tests` tool (runs the configured test command). */
+  runTests(opts?: {
+    name?: string;
+    command?: string;
+  }): ToolContract;
+  /** The `grep` tool (regex content search). */
+  grep(opts?: {
+    name?: string;
+  }): ToolContract;
+  /** The `glob` tool (path pattern match). */
+  glob(opts?: {
+    name?: string;
+  }): ToolContract;
+}
+/**
+ * The bounded place an agent reads, writes, and runs commands — a
+ * policy-enforced handle to a filesystem + shell. One policy, one shared
+ * ops layer, two ways to touch it: the agent uses `.tools.*`; you use the
+ * direct methods.
+ *
+ * This is the **W1 surface only**: the policy jail, the seven tools, the
+ * direct methods, `tools.all()` / `tools.pick()`, plus the two
+ * composition projections `readonly()` and `scope()`. The transactional
+ * lifecycle (`snapshot` / `restore` / `diff` / `changes`), hooks
+ * (`on`), `dispose`, `usage`, and the worktree/container backends are
+ * deferred to later phases and intentionally absent here.
+ *
+ * @example
+ * const ws = ai.workspace({ cwd: "/srv/acme-api", shell: { allow: ["npm"], inheritEnv: ["PATH"] } });
+ * const dev = ai.agent({ model, tools: ws.tools.all() });
+ * await dev.execute("Make the failing cart-total suite green.");
+ *
+ * @example
+ * // Drive it directly from code.
+ * await ws.writeFile("src/routes.ts", BOILERPLATE);
+ * const files = await ws.glob("src/models/**\/*.ts");
+ */
+interface Workspace {
+  /** The immutable policy bounding this workspace. */
+  readonly policy: WorkspacePolicy;
+  /** Agent-facing tool factories. */
+  readonly tools: WorkspaceTools;
+  /**
+   * Read a jailed file. `offset`/`limit` select a 1-based line window;
+   * returns the content, its SHA-256 `hash`, and the file's total line
+   * count (for read-before-edit).
+   */
+  readFile(path: string, opts?: {
+    offset?: number;
+    limit?: number;
+  }): Promise<{
+    content: string;
+    hash: string;
+    totalLines: number;
+  }>;
+  /** Atomically write full content to a jailed path. */
+  writeFile(path: string, content: string): Promise<{
+    hash: string;
+    bytesWritten: number;
+  }>;
+  /** Apply an exact-string edit under the read-before-edit stale guard. */
+  editFile(input: EditFileInput): Promise<EditFileResult>;
+  /** Run a policy-gated shell command and capture its outcome. */
+  exec(command: string, opts?: {
+    timeoutMs?: number;
+  }): Promise<RunShellResult>;
+  /** Search jailed file contents for a regex pattern. */
+  grep(pattern: string, opts?: {
+    glob?: string;
+    ignoreCase?: boolean;
+  }): Promise<GrepResult>;
+  /** Resolve a glob to matching workspace-relative paths within the jail. */
+  glob(pattern: string): Promise<string[]>;
+  /** Whether a jailed path exists (file or directory). */
+  exists(path: string): Promise<boolean>;
+  /** Create a directory (and parents) at a jailed path; idempotent. */
+  mkdir(path: string): Promise<void>;
+  /** Remove a file or directory tree at a jailed path. */
+  remove(path: string): Promise<void>;
+  /**
+   * A read-only projection of this workspace — the same jail and state,
+   * but the write/edit/shell tools are omitted from `tools.*` and the
+   * mutating direct methods reject. For least-privilege reviewers.
+   */
+  readonly(): Workspace;
+  /**
+   * A sub-jailed view rooted at `subdir` (relative to this workspace's
+   * `cwd`), sharing the same backend. Narrows the blast radius — e.g.
+   * `ws.scope("packages/api")` jails an agent to that package.
+   */
+  scope(subdir: string): Workspace;
+}
+//#endregion
+export { Workspace, WorkspaceTools };
+//# sourceMappingURL=workspace.contract.d.mts.map

package/esm/contracts/workspace.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-workspace/src/contracts/workspace.contract.ts"],"mappings":";;;;;;;AAoBA;;;;;;;;UAAiB,cAAA;EAYqB;EAVpC,GAAA,IAAO,YAAA;EAcyB;EAZhC,IAAA,IAAQ,KAAA,EAAO,iBAAA,KAAsB,YAAA;EAcO;EAZ5C,QAAA,CAAS,IAAA;IAAS,IAAA;EAAA,IAAkB,YAAA;EAFpC;EAIA,QAAA,CAAS,IAAA;IAAS,IAAA;EAAA,IAAkB,YAAA;EAFpC;EAIA,SAAA,CAAU,IAAA;IAAS,IAAA;EAAA,IAAkB,YAAA;EAFrC;EAIA,QAAA,CAAS,IAAA;IAAS,IAAA;EAAA,IAAkB,YAAA;EAFpC;EAIA,QAAA,CAAS,IAAA;IAAS,IAAA;IAAe,OAAA;EAAA,IAAqB,YAAA;EAFpC;EAIlB,IAAA,CAAK,IAAA;IAAS,IAAA;EAAA,IAAkB,YAAA;EAFd;EAIlB,IAAA,CAAK,IAAA;IAAS,IAAA;EAAA,IAAkB,YAAA;AAAA;;;;;;;;;AAAY;AA0B9C;;;;;;;;;;;;;;UAAiB,SAAA;EAuCO;EAAA,SArCb,MAAA,EAAQ,eAAA;EA2CK;EAAA,SAxCb,KAAA,EAAO,cAAA;EAsDO;;;;;EA/CvB,QAAA,CACE,IAAA,UACA,IAAA;IAAS,MAAA;IAAiB,KAAA;EAAA,IACzB,OAAA;IAAU,OAAA;IAAiB,IAAA;IAAc,UAAA;EAAA;EAA/B;EAGb,SAAA,CACE,IAAA,UACA,OAAA,WACC,OAAA;IAAU,IAAA;IAAc,YAAA;EAAA;EADzB;EAIF,QAAA,CAAS,KAAA,EAAO,aAAA,GAAgB,OAAA,CAAQ,cAAA;EAH3B;EAMb,IAAA,CAAK,OAAA,UAAiB,IAAA;IAAS,SAAA;EAAA,IAAuB,OAAA,CAAQ,cAAA;EAHrD;EAMT,IAAA,CACE,OAAA,UACA,IAAA;IAAS,IAAA;IAAe,UAAA;EAAA,IACvB,OAAA,CAAQ,UAAA;EANoB;EAS/B,IAAA,CAAK,OAAA,WAAkB,OAAA;EAT+B;EAYtD,MAAA,CAAO,IAAA,WAAe,OAAA;EATtB;EAYA,KAAA,CAAM,IAAA,WAAe,OAAA;EAVV;EAaX,MAAA,CAAO,IAAA,WAAe,OAAA;EAbpB;;;;;EAoBF,QAAA,IAAY,SAAA;EAbZ;;;;;EAoBA,KAAA,CAAM,MAAA,WAAiB,SAAA;AAAA"}

package/esm/errors.d.mts

@@ -0,0 +1,100 @@
+import { AIError, AIErrorOptions } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-workspace/src/errors.d.ts
+/**
+ * Why a workspace policy check rejected an operation.
+ *
+ * - `"path-escape"` — a resolved path fell outside the `cwd` jail (or an
+ *   `allowPaths` root), or matched a `denyPaths` glob.
+ * - `"denied-command"` — a shell command's leading executable basename
+ *   was not in `shell.allow`, or was explicitly in `shell.deny`.
+ */
+type WorkspacePolicyViolation = "path-escape" | "denied-command";
+/**
+ * Options for {@link WorkspacePolicyError} — the structured `type`
+ * discriminator plus, where relevant, the offending path or command for
+ * branchable diagnostics without parsing the message.
+ */
+type WorkspacePolicyErrorOptions = AIErrorOptions & {
+  /** Which policy rule was violated. */type: WorkspacePolicyViolation; /** The offending workspace-relative path (for `"path-escape"`). */
+  path?: string; /** The offending command line (for `"denied-command"`). */
+  command?: string;
+};
+/**
+ * The workspace policy engine refused an operation — a path escaped the
+ * jail (or hit a deny glob), or a shell command's executable was not
+ * allowed.
+ *
+ * **Surface.** This is returned to the agent as tool-error *data*, never
+ * a thrown run-killer — the agent reads the failure and self-corrects.
+ * Extends the framework `AIError` (category `"tool"`, code
+ * `TOOL_EXEC_FAILED`) so it flows through the same typed error contract
+ * as every other AI error; branch on `error.type` for the specific
+ * violation.
+ *
+ * @example
+ * if (error instanceof WorkspacePolicyError && error.type === "denied-command") {
+ *   console.warn(`Blocked command: ${error.command}`);
+ * }
+ */
+declare class WorkspacePolicyError extends AIError {
+  /** Which policy rule was violated. */
+  readonly type: WorkspacePolicyViolation;
+  /** The offending path, when the violation was a path escape. */
+  readonly path?: string;
+  /** The offending command, when the violation was a denied command. */
+  readonly command?: string;
+  constructor(message: string, options: WorkspacePolicyErrorOptions);
+}
+/**
+ * Why an edit was rejected.
+ *
+ * - `"not-found"` — the `oldString` did not appear in the file.
+ * - `"not-unique"` — `oldString` matched more than once and `replaceAll`
+ *   was not set, so the edit is ambiguous.
+ * - `"stale-hash"` — the file's current hash did not match the supplied
+ *   `expectHash`; the file changed since it was read.
+ */
+type WorkspaceEditFailure = "not-found" | "not-unique" | "stale-hash";
+/**
+ * Options for {@link WorkspaceEditError} — the structured `type`
+ * discriminator plus optional match-count / hash context for the
+ * `"not-unique"` and `"stale-hash"` cases.
+ */
+type WorkspaceEditErrorOptions = AIErrorOptions & {
+  /** Why the edit was rejected. */type: WorkspaceEditFailure; /** The edited file's workspace-relative path. */
+  path: string; /** How many times `oldString` matched (for `"not-unique"`). */
+  matches?: number; /** The hash the caller expected (for `"stale-hash"`). */
+  expectedHash?: string; /** The file's actual current hash (for `"stale-hash"`). */
+  actualHash?: string;
+};
+/**
+ * An `editFile` operation was rejected by the read-before-edit guard:
+ * the `oldString` was absent, matched non-uniquely without `replaceAll`,
+ * or the file's hash no longer matched the supplied `expectHash`.
+ *
+ * **Surface.** Like {@link WorkspacePolicyError}, returned to the agent
+ * as tool-error *data* so it can re-read and retry. Extends `AIError`
+ * (category `"tool"`, code `TOOL_EXEC_FAILED`); branch on `error.type`.
+ *
+ * @example
+ * if (error instanceof WorkspaceEditError && error.type === "stale-hash") {
+ *   // re-read the file and retry the edit with the fresh hash
+ * }
+ */
+declare class WorkspaceEditError extends AIError {
+  /** Why the edit was rejected. */
+  readonly type: WorkspaceEditFailure;
+  /** The edited file's workspace-relative path. */
+  readonly path: string;
+  /** How many times `oldString` matched, for the `"not-unique"` case. */
+  readonly matches?: number;
+  /** The hash the caller expected, for the `"stale-hash"` case. */
+  readonly expectedHash?: string;
+  /** The file's actual current hash, for the `"stale-hash"` case. */
+  readonly actualHash?: string;
+  constructor(message: string, options: WorkspaceEditErrorOptions);
+}
+//#endregion
+export { WorkspaceEditError, WorkspaceEditErrorOptions, WorkspaceEditFailure, WorkspacePolicyError, WorkspacePolicyErrorOptions, WorkspacePolicyViolation };
+//# sourceMappingURL=errors.d.mts.map

package/esm/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai-workspace/src/errors.ts"],"mappings":";;;;;AAUA;;;;AAAoC;AAOpC;KAPY,wBAAA;;;;;;KAOA,2BAAA,GAA8B,cAAA;EAMxC,sCAJA,IAAA,EAAM,wBAAwB,EAIvB;EAFP,IAAA,WAsBgC;EApBhC,OAAA;AAAA;;;;;;;;;;;;;;;AA4BwE;AAmB1E;;cA3Ba,oBAAA,SAA6B,OAAA;EA2BV;EAAA,SAzBd,IAAA,EAAM,wBAAA;EAgCZ;EAAA,SA9BM,IAAA;;WAEA,OAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,2BAAA;AAAA;;;;;;;AAoCnC;AAiBZ;;KAlCY,oBAAA;;;;;;KAOA,yBAAA,GAA4B,cAAA;EA6BtB,iCA3BhB,IAAA,EAAM,oBAAoB,EA6BV;EA3BhB,IAAA,UA+BgB;EA7BhB,OAAA;EAEA,YAAA,WA+B6C;EA7B7C,UAAA;AAAA;AA6BsE;;;;;;;;;;;;;;AAAA,cAZ3D,kBAAA,SAA2B,OAAA;;WAEtB,IAAA,EAAM,oBAAA;;WAEN,IAAA;;WAEA,OAAA;;WAEA,YAAA;;WAEA,UAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,yBAAA;AAAA"}

package/esm/errors.mjs

@@ -0,0 +1,58 @@
+import { AIError } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-workspace/src/errors.ts
+/**
+* The workspace policy engine refused an operation — a path escaped the
+* jail (or hit a deny glob), or a shell command's executable was not
+* allowed.
+*
+* **Surface.** This is returned to the agent as tool-error *data*, never
+* a thrown run-killer — the agent reads the failure and self-corrects.
+* Extends the framework `AIError` (category `"tool"`, code
+* `TOOL_EXEC_FAILED`) so it flows through the same typed error contract
+* as every other AI error; branch on `error.type` for the specific
+* violation.
+*
+* @example
+* if (error instanceof WorkspacePolicyError && error.type === "denied-command") {
+*   console.warn(`Blocked command: ${error.command}`);
+* }
+*/
+var WorkspacePolicyError = class extends AIError {
+	constructor(message, options) {
+		super("TOOL_EXEC_FAILED", message, options);
+		this.name = "WorkspacePolicyError";
+		this.type = options.type;
+		this.path = options.path;
+		this.command = options.command;
+	}
+};
+/**
+* An `editFile` operation was rejected by the read-before-edit guard:
+* the `oldString` was absent, matched non-uniquely without `replaceAll`,
+* or the file's hash no longer matched the supplied `expectHash`.
+*
+* **Surface.** Like {@link WorkspacePolicyError}, returned to the agent
+* as tool-error *data* so it can re-read and retry. Extends `AIError`
+* (category `"tool"`, code `TOOL_EXEC_FAILED`); branch on `error.type`.
+*
+* @example
+* if (error instanceof WorkspaceEditError && error.type === "stale-hash") {
+*   // re-read the file and retry the edit with the fresh hash
+* }
+*/
+var WorkspaceEditError = class extends AIError {
+	constructor(message, options) {
+		super("TOOL_EXEC_FAILED", message, options);
+		this.name = "WorkspaceEditError";
+		this.type = options.type;
+		this.path = options.path;
+		this.matches = options.matches;
+		this.expectedHash = options.expectedHash;
+		this.actualHash = options.actualHash;
+	}
+};
+
+//#endregion
+export { WorkspaceEditError, WorkspacePolicyError };
+//# sourceMappingURL=errors.mjs.map

package/esm/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-workspace/src/errors.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"@warlock.js/ai\";\n\n/**\n * Why a workspace policy check rejected an operation.\n *\n * - `\"path-escape\"` — a resolved path fell outside the `cwd` jail (or an\n *   `allowPaths` root), or matched a `denyPaths` glob.\n * - `\"denied-command\"` — a shell command's leading executable basename\n *   was not in `shell.allow`, or was explicitly in `shell.deny`.\n */\nexport type WorkspacePolicyViolation = \"path-escape\" | \"denied-command\";\n\n/**\n * Options for {@link WorkspacePolicyError} — the structured `type`\n * discriminator plus, where relevant, the offending path or command for\n * branchable diagnostics without parsing the message.\n */\nexport type WorkspacePolicyErrorOptions = AIErrorOptions & {\n  /** Which policy rule was violated. */\n  type: WorkspacePolicyViolation;\n  /** The offending workspace-relative path (for `\"path-escape\"`). */\n  path?: string;\n  /** The offending command line (for `\"denied-command\"`). */\n  command?: string;\n};\n\n/**\n * The workspace policy engine refused an operation — a path escaped the\n * jail (or hit a deny glob), or a shell command's executable was not\n * allowed.\n *\n * **Surface.** This is returned to the agent as tool-error *data*, never\n * a thrown run-killer — the agent reads the failure and self-corrects.\n * Extends the framework `AIError` (category `\"tool\"`, code\n * `TOOL_EXEC_FAILED`) so it flows through the same typed error contract\n * as every other AI error; branch on `error.type` for the specific\n * violation.\n *\n * @example\n * if (error instanceof WorkspacePolicyError && error.type === \"denied-command\") {\n *   console.warn(`Blocked command: ${error.command}`);\n * }\n */\nexport class WorkspacePolicyError extends AIError {\n  /** Which policy rule was violated. */\n  public readonly type: WorkspacePolicyViolation;\n  /** The offending path, when the violation was a path escape. */\n  public readonly path?: string;\n  /** The offending command, when the violation was a denied command. */\n  public readonly command?: string;\n\n  public constructor(message: string, options: WorkspacePolicyErrorOptions) {\n    super(\"TOOL_EXEC_FAILED\", message, options);\n\n    this.name = \"WorkspacePolicyError\";\n    this.type = options.type;\n    this.path = options.path;\n    this.command = options.command;\n  }\n}\n\n/**\n * Why an edit was rejected.\n *\n * - `\"not-found\"` — the `oldString` did not appear in the file.\n * - `\"not-unique\"` — `oldString` matched more than once and `replaceAll`\n *   was not set, so the edit is ambiguous.\n * - `\"stale-hash\"` — the file's current hash did not match the supplied\n *   `expectHash`; the file changed since it was read.\n */\nexport type WorkspaceEditFailure = \"not-found\" | \"not-unique\" | \"stale-hash\";\n\n/**\n * Options for {@link WorkspaceEditError} — the structured `type`\n * discriminator plus optional match-count / hash context for the\n * `\"not-unique\"` and `\"stale-hash\"` cases.\n */\nexport type WorkspaceEditErrorOptions = AIErrorOptions & {\n  /** Why the edit was rejected. */\n  type: WorkspaceEditFailure;\n  /** The edited file's workspace-relative path. */\n  path: string;\n  /** How many times `oldString` matched (for `\"not-unique\"`). */\n  matches?: number;\n  /** The hash the caller expected (for `\"stale-hash\"`). */\n  expectedHash?: string;\n  /** The file's actual current hash (for `\"stale-hash\"`). */\n  actualHash?: string;\n};\n\n/**\n * An `editFile` operation was rejected by the read-before-edit guard:\n * the `oldString` was absent, matched non-uniquely without `replaceAll`,\n * or the file's hash no longer matched the supplied `expectHash`.\n *\n * **Surface.** Like {@link WorkspacePolicyError}, returned to the agent\n * as tool-error *data* so it can re-read and retry. Extends `AIError`\n * (category `\"tool\"`, code `TOOL_EXEC_FAILED`); branch on `error.type`.\n *\n * @example\n * if (error instanceof WorkspaceEditError && error.type === \"stale-hash\") {\n *   // re-read the file and retry the edit with the fresh hash\n * }\n */\nexport class WorkspaceEditError extends AIError {\n  /** Why the edit was rejected. */\n  public readonly type: WorkspaceEditFailure;\n  /** The edited file's workspace-relative path. */\n  public readonly path: string;\n  /** How many times `oldString` matched, for the `\"not-unique\"` case. */\n  public readonly matches?: number;\n  /** The hash the caller expected, for the `\"stale-hash\"` case. */\n  public readonly expectedHash?: string;\n  /** The file's actual current hash, for the `\"stale-hash\"` case. */\n  public readonly actualHash?: string;\n\n  public constructor(message: string, options: WorkspaceEditErrorOptions) {\n    super(\"TOOL_EXEC_FAILED\", message, options);\n\n    this.name = \"WorkspaceEditError\";\n    this.type = options.type;\n    this.path = options.path;\n    this.matches = options.matches;\n    this.expectedHash = options.expectedHash;\n    this.actualHash = options.actualHash;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,uBAAb,cAA0C,QAAQ;CAQhD,AAAO,YAAY,SAAiB,SAAsC;EACxE,MAAM,oBAAoB,SAAS,OAAO;EAE1C,KAAK,OAAO;EACZ,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;CACzB;AACF;;;;;;;;;;;;;;;AA6CA,IAAa,qBAAb,cAAwC,QAAQ;CAY9C,AAAO,YAAY,SAAiB,SAAoC;EACtE,MAAM,oBAAoB,SAAS,OAAO;EAE1C,KAAK,OAAO;EACZ,KAAK,OAAO,QAAQ;EACpB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,eAAe,QAAQ;EAC5B,KAAK,aAAa,QAAQ;CAC5B;AACF"}

package/esm/index.d.mts

@@ -0,0 +1,20 @@
+import { EditFileInput, EditFileResult, GlobInput, GlobResult, GrepInput, GrepMatch, GrepResult, ReadFileInput, ReadFileResult, RunShellInput, RunShellResult, RunTestsInput, WorkspaceToolName, WriteFileInput, WriteFileResult } from "./contracts/tool-io.type.mjs";
+import { WorkspaceBackend, WorkspaceBackendExecOptions, WorkspaceBackendExecResult } from "./contracts/workspace-backend.contract.mjs";
+import { WorkspaceOps } from "./contracts/workspace-ops.contract.mjs";
+import { WorkspaceBackendType, WorkspacePolicy, WorkspaceReadPolicy, WorkspaceShellPolicy } from "./contracts/workspace-policy.type.mjs";
+import { Workspace, WorkspaceTools } from "./contracts/workspace.contract.mjs";
+import { WorkspaceEditError, WorkspaceEditErrorOptions, WorkspaceEditFailure, WorkspacePolicyError, WorkspacePolicyErrorOptions, WorkspacePolicyViolation } from "./errors.mjs";
+import { ResolvedPath, buildEnv, isCommandAllowed, resolveInJail } from "./policy/policy.mjs";
+import { createOps } from "./ops.mjs";
+import { createLocalBackend } from "./backends/local.mjs";
+import { MockBackendSeed, MockExecResult, createMockBackend } from "./backends/mock.mjs";
+import { makeEditFileTool } from "./tools/edit-file.mjs";
+import { MakeGlobToolOptions, makeGlobTool } from "./tools/glob.mjs";
+import { MakeGrepToolOptions, makeGrepTool } from "./tools/grep.mjs";
+import { makeReadFileTool } from "./tools/read-file.mjs";
+import { MakeRunShellToolOptions, makeRunShellTool } from "./tools/run-shell.mjs";
+import { MakeRunTestsToolOptions, makeRunTestsTool } from "./tools/run-tests.mjs";
+import { makeWriteFileTool } from "./tools/write-file.mjs";
+import { workspace } from "./workspace.mjs";
+export { type EditFileInput, type EditFileResult, type GlobInput, type GlobResult, type GrepInput, type GrepMatch, type GrepResult, type MakeGlobToolOptions, type MakeGrepToolOptions, type MakeRunShellToolOptions, type MakeRunTestsToolOptions, type MockBackendSeed, type MockExecResult, type ReadFileInput, type ReadFileResult, type ResolvedPath, type RunShellInput, type RunShellResult, type RunTestsInput, type Workspace, type WorkspaceBackend, type WorkspaceBackendExecOptions, type WorkspaceBackendExecResult, type WorkspaceBackendType, WorkspaceEditError, type WorkspaceEditErrorOptions, type WorkspaceEditFailure, type WorkspaceOps, type WorkspacePolicy, WorkspacePolicyError, type WorkspacePolicyErrorOptions, type WorkspacePolicyViolation, type WorkspaceReadPolicy, type WorkspaceShellPolicy, type WorkspaceToolName, type WorkspaceTools, type WriteFileInput, type WriteFileResult, buildEnv, createLocalBackend, createMockBackend, createOps, isCommandAllowed, makeEditFileTool, makeGlobTool, makeGrepTool, makeReadFileTool, makeRunShellTool, makeRunTestsTool, makeWriteFileTool, resolveInJail, workspace };
+import "./workspace.mjs";

package/esm/index.mjs

@@ -0,0 +1,15 @@
+import { WorkspaceEditError, WorkspacePolicyError } from "./errors.mjs";
+import { buildEnv, isCommandAllowed, resolveInJail } from "./policy/policy.mjs";
+import { createOps } from "./ops.mjs";
+import { createLocalBackend } from "./backends/local.mjs";
+import { createMockBackend } from "./backends/mock.mjs";
+import { makeEditFileTool } from "./tools/edit-file.mjs";
+import { makeGlobTool } from "./tools/glob.mjs";
+import { makeGrepTool } from "./tools/grep.mjs";
+import { makeReadFileTool } from "./tools/read-file.mjs";
+import { makeRunShellTool } from "./tools/run-shell.mjs";
+import { makeRunTestsTool } from "./tools/run-tests.mjs";
+import { makeWriteFileTool } from "./tools/write-file.mjs";
+import { workspace } from "./workspace.mjs";
+
+export { WorkspaceEditError, WorkspacePolicyError, buildEnv, createLocalBackend, createMockBackend, createOps, isCommandAllowed, makeEditFileTool, makeGlobTool, makeGrepTool, makeReadFileTool, makeRunShellTool, makeRunTestsTool, makeWriteFileTool, resolveInJail, workspace };

package/esm/ops.d.mts

@@ -0,0 +1,25 @@
+import { WorkspaceBackend } from "./contracts/workspace-backend.contract.mjs";
+import { WorkspaceOps } from "./contracts/workspace-ops.contract.mjs";
+import { WorkspacePolicy } from "./contracts/workspace-policy.type.mjs";
+//#region ../@warlock.js/ai-workspace/src/ops.d.ts
+/**
+ * Create the policy-enforced operation layer over a backend.
+ *
+ * The returned {@link WorkspaceOps} is the single seam both the
+ * agent-facing `.tools.*` factories and the human-facing direct methods
+ * delegate to — one jail, one command-gate, one read-before-edit guard,
+ * regardless of caller. Path inputs are workspace-relative and resolved
+ * against `policy.cwd`; escapes and denied commands surface as typed
+ * {@link WorkspacePolicyError} / {@link WorkspaceEditError}.
+ *
+ * @param backend - The dumb IO executor (local disk or in-memory mock).
+ * @param policy - The policy that bounds every operation.
+ *
+ * @example
+ * const ops = createOps(localBackend, { cwd: "/srv/api", shell: { allow: ["npm"] } });
+ * const { content, hash } = await ops.readFile("src/index.ts");
+ */
+declare function createOps(backend: WorkspaceBackend, policy: WorkspacePolicy): WorkspaceOps;
+//#endregion
+export { createOps };
+//# sourceMappingURL=ops.d.mts.map

package/esm/ops.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ops.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai-workspace/src/ops.ts"],"mappings":";;;;;;;;;AAqbA;;;;;;;;;;;;iBAAgB,SAAA,CACd,OAAA,EAAS,gBAAA,EACT,MAAA,EAAQ,eAAA,GACP,YAAA"}