anpord 0.1.25 → 0.1.27

package/dist/api-context.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_api_mocks = require("./api-mocks-BEorMdN5.cjs");
+const require_api_mocks = require("./api-mocks-BsUGpsim.cjs");
 let effect = require("effect");
 let node_fs_promises = require("node:fs/promises");
 //#region src/mock-api/context.ts

package/dist/api-context.d.cts

@@ -1,4 +1,4 @@
-import { t as ApiCall } from "./api-mocks-bVa7eYtc.cjs";
+import { t as ApiCall } from "./api-mocks-CBa3MWVP.cjs";
 //#region src/mock-api/context.d.ts
 declare const apiContext: {
   url: (name: string) => Promise<string>;

package/dist/api-context.d.mts

@@ -1,4 +1,4 @@
-import { t as ApiCall } from "./api-mocks-bVa7eYtc.mjs";
+import { t as ApiCall } from "./api-mocks-CBa3MWVP.mjs";
 //#region src/mock-api/context.d.ts
 declare const apiContext: {
   url: (name: string) => Promise<string>;

package/dist/api-context.mjs

@@ -1,4 +1,4 @@
-import { a as ApiCall, n as API_MANIFEST, o as ApiManifest, t as API_JOURNAL } from "./api-mocks-RCkffSgG.mjs";
+import { n as API_MANIFEST, o as ApiCall, s as ApiManifest, t as API_JOURNAL } from "./api-mocks-DH1C7any.mjs";
 import { Schema } from "effect";
 import { readFile } from "node:fs/promises";
 //#region src/mock-api/context.ts

package/dist/{api-mocks-BEorMdN5.cjs → api-mocks-BsUGpsim.cjs}

@@ -1,25 +1,56 @@
-const require_eval_judges = require("./eval-judges-1zF4PVqV.cjs");
+const require_eval_judges = require("./eval-judges-CO0ds-HQ.cjs");
 let effect = require("effect");
+//#region ../schema/src/domain/secret-text.ts
+const REDACTED = "[redacted]";
+const KNOWN_MINIMUM = 8;
+const EDGE = "(?<![A-Za-z0-9_-])";
+const HAS_DIGIT = "(?=[A-Za-z0-9._~+/-]*[0-9])";
+const CREDENTIAL = new RegExp([
+	`${EDGE}sk-${HAS_DIGIT}[A-Za-z0-9_-]{20,}`,
+	`${EDGE}[rs]k_(?:live|test)_[A-Za-z0-9]{10,}`,
+	`${EDGE}am_sk_[A-Za-z0-9_-]+`,
+	`${EDGE}anp_[A-Za-z0-9_-]{16,}`,
+	`${EDGE}gh[pousr]_[A-Za-z0-9]{20,}`,
+	`${EDGE}github_pat_[A-Za-z0-9_]{20,}`,
+	`${EDGE}xox[abeoprs]-[A-Za-z0-9-]{10,}`,
+	`${EDGE}(?:AKIA|ASIA)[A-Z0-9]{16}`,
+	`${EDGE}AIza[A-Za-z0-9_-]{35}`,
+	`${EDGE}eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}`,
+	`(?<=\\b[Bb]earer\\s+)${HAS_DIGIT}[A-Za-z0-9._~+/-]{16,}=*`,
+	"(?<=[a-z][a-z0-9+.-]*://[^/\\s:@]+:)[^/\\s@]+(?=@)",
+	"-----BEGIN [A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END [A-Z ]*PRIVATE KEY-----"
+].join("|"), "g");
+const escapedForms = (value) => [value, JSON.stringify(value).slice(1, -1)];
+const redactSecrets = (text, known = []) => known.filter((value) => value.length >= KNOWN_MINIMUM).flatMap(escapedForms).toSorted((left, right) => right.length - left.length).reduce((redacted, value) => redacted.replaceAll(value, REDACTED), text).replace(CREDENTIAL, REDACTED);
+//#endregion
 //#region ../schema/src/domain/eval-validations.ts
 const VALIDATION_TEXT_LIMIT = 16e3;
 const VALIDATION_BUDGET = 64e3;
 const VALIDATION_FRAME = "ANPORD_VALIDATION=";
-const ValidationValue = effect.Schema.Struct({
-	text: effect.Schema.String.pipe(effect.Schema.maxLength(VALIDATION_TEXT_LIMIT)),
+const EVIDENCE_LIMITS = {
+	budget: VALIDATION_BUDGET,
+	text: VALIDATION_TEXT_LIMIT
+};
+const REPORTED_LIMITS = {
+	budget: 192e3,
+	text: 64e3
+};
+const valueWithin = (limit) => effect.Schema.Struct({
+	text: effect.Schema.String.pipe(effect.Schema.maxLength(limit)),
 	format: effect.Schema.Literal("text", "json"),
 	state: effect.Schema.Literal("captured", "disabled", "unavailable"),
 	truncated: effect.Schema.Boolean
-}).annotations({ identifier: "ValidationValue" });
-const ValidationCall = effect.Schema.Struct({
+});
+const callOf = (value) => effect.Schema.Struct({
 	index: effect.Schema.NonNegativeInt,
 	method: effect.Schema.Literal("answer", "transcript", "turns", "readText", "exists", "exec", "cli.calls", "api.calls", "api.url", "mcp.calls"),
 	startedAt: effect.Schema.Number,
 	durationMs: effect.Schema.NullOr(effect.Schema.NonNegativeInt),
-	input: ValidationValue,
-	output: ValidationValue,
-	error: effect.Schema.NullOr(ValidationValue)
-}).annotations({ identifier: "ValidationCall" });
-const EvalValidation = effect.Schema.Struct({
+	input: value,
+	output: value,
+	error: effect.Schema.NullOr(value)
+});
+const validationOf = (value, call) => effect.Schema.Struct({
 	id: effect.Schema.String.pipe(effect.Schema.minLength(1), effect.Schema.maxLength(200)),
 	index: effect.Schema.NonNegativeInt,
 	name: effect.Schema.String.pipe(effect.Schema.maxLength(200)),
@@ -31,18 +62,22 @@ const EvalValidation = effect.Schema.Struct({
 	exitCode: effect.Schema.NullOr(effect.Schema.Int),
 	truncated: effect.Schema.Boolean,
 	judgment: effect.Schema.optional(require_eval_judges.EvalJudgment),
-	input: ValidationValue,
-	output: ValidationValue,
-	error: effect.Schema.NullOr(ValidationValue),
-	metadata: effect.Schema.optional(ValidationValue),
-	calls: effect.Schema.Array(ValidationCall).pipe(effect.Schema.maxItems(64)),
+	input: value,
+	output: value,
+	error: effect.Schema.NullOr(value),
+	metadata: effect.Schema.optional(value),
+	calls: effect.Schema.Array(call).pipe(effect.Schema.maxItems(64)),
 	logs: effect.Schema.Array(effect.Schema.Struct({
 		index: effect.Schema.NonNegativeInt,
 		at: effect.Schema.Number,
 		level: effect.Schema.Literal("stdout", "stderr"),
-		value: ValidationValue
+		value
 	})).pipe(effect.Schema.maxItems(64))
-}).annotations({ identifier: "EvalValidation" });
+});
+const ValidationValue = valueWithin(VALIDATION_TEXT_LIMIT).annotations({ identifier: "ValidationValue" });
+const EvalValidation = validationOf(ValidationValue, callOf(ValidationValue).annotations({ identifier: "ValidationCall" })).annotations({ identifier: "EvalValidation" });
+const ReportedValue = valueWithin(REPORTED_LIMITS.text);
+const ReportedValidation = validationOf(ReportedValue, callOf(ReportedValue));
 const EvalValidations = effect.Schema.Array(EvalValidation).pipe(effect.Schema.maxItems(40)).annotations({ identifier: "EvalValidations" });
 const validationSnapshot = (value) => ({
 	...value,
@@ -65,8 +100,8 @@ const unavailableValue = {
 	state: "unavailable",
 	truncated: false
 };
-const validationCapture = (enabled = true) => {
-	let remaining = VALIDATION_BUDGET;
+const validationCapture = (enabled = true, secrets = [], limits = EVIDENCE_LIMITS) => {
+	let remaining = limits.budget;
 	return (value, format = "json") => {
 		if (!enabled) return {
 			...unavailableValue,
@@ -74,12 +109,13 @@ const validationCapture = (enabled = true) => {
 			format
 		};
 		try {
-			const raw = format === "text" ? String(value) : JSON.stringify(value);
-			if (raw === void 0) return {
+			const encoded = format === "text" ? String(value) : JSON.stringify(value);
+			if (encoded === void 0) return {
 				...unavailableValue,
 				format
 			};
-			const text = raw.slice(0, Math.min(remaining, VALIDATION_TEXT_LIMIT));
+			const raw = redactSecrets(encoded, secrets);
+			const text = raw.slice(0, Math.min(remaining, limits.text));
 			remaining -= text.length;
 			return {
 				text,
@@ -114,7 +150,13 @@ const validationExecution = (identity, startedAt) => ({
 const API_PROGRAM = "workspace/.anpord/api/program.json";
 const API_MANIFEST = ".anpord/api/manifest.json";
 const API_JOURNAL = ".anpord/api/calls.jsonl";
+const CLI_JOURNAL = ".anpord/cli-calls.jsonl";
+const MCP_JOURNAL = ".anpord/mcp-calls.jsonl";
 const API_READY = "ANPORD_API_READY=";
+const API_REPORTED_LIMITS = {
+	budget: 96e3,
+	text: 64e3
+};
 const ApiProgram = effect.Schema.Struct({ entry: effect.Schema.Literal(".anpord/api/server.mjs") });
 const ApiManifest = effect.Schema.Array(effect.Schema.Struct({
 	name: effect.Schema.String,
@@ -133,11 +175,11 @@ var ApiCall = class extends effect.Schema.Class("ApiCall")({
 	matched: effect.Schema.Boolean,
 	startedAt: effect.Schema.Number,
 	durationMs: effect.Schema.NonNegativeInt,
-	input: ValidationValue,
-	output: ValidationValue,
+	input: ReportedValue,
+	output: ReportedValue,
 	status: effect.Schema.Int,
 	error: effect.Schema.NullOr(effect.Schema.String.pipe(effect.Schema.maxLength(2e3))),
-	logs: effect.Schema.Array(ValidationValue).pipe(effect.Schema.maxItems(64))
+	logs: effect.Schema.Array(ReportedValue).pipe(effect.Schema.maxItems(64))
 }) {};
 //#endregion
 Object.defineProperty(exports, "API_JOURNAL", {
@@ -164,6 +206,12 @@ Object.defineProperty(exports, "API_READY", {
 		return API_READY;
 	}
 });
+Object.defineProperty(exports, "API_REPORTED_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return API_REPORTED_LIMITS;
+	}
+});
 Object.defineProperty(exports, "ApiCall", {
 	enumerable: true,
 	get: function() {
@@ -182,10 +230,16 @@ Object.defineProperty(exports, "ApiProgram", {
 		return ApiProgram;
 	}
 });
-Object.defineProperty(exports, "EvalValidation", {
+Object.defineProperty(exports, "CLI_JOURNAL", {
+	enumerable: true,
+	get: function() {
+		return CLI_JOURNAL;
+	}
+});
+Object.defineProperty(exports, "EVIDENCE_LIMITS", {
 	enumerable: true,
 	get: function() {
-		return EvalValidation;
+		return EVIDENCE_LIMITS;
 	}
 });
 Object.defineProperty(exports, "EvalValidations", {
@@ -194,6 +248,24 @@ Object.defineProperty(exports, "EvalValidations", {
 		return EvalValidations;
 	}
 });
+Object.defineProperty(exports, "MCP_JOURNAL", {
+	enumerable: true,
+	get: function() {
+		return MCP_JOURNAL;
+	}
+});
+Object.defineProperty(exports, "REPORTED_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return REPORTED_LIMITS;
+	}
+});
+Object.defineProperty(exports, "ReportedValidation", {
+	enumerable: true,
+	get: function() {
+		return ReportedValidation;
+	}
+});
 Object.defineProperty(exports, "VALIDATION_FRAME", {
 	enumerable: true,
 	get: function() {
@@ -206,6 +278,12 @@ Object.defineProperty(exports, "VALIDATION_TEXT_LIMIT", {
 		return VALIDATION_TEXT_LIMIT;
 	}
 });
+Object.defineProperty(exports, "redactSecrets", {
+	enumerable: true,
+	get: function() {
+		return redactSecrets;
+	}
+});
 Object.defineProperty(exports, "unavailableValue", {
 	enumerable: true,
 	get: function() {

package/dist/api-mocks-CBa3MWVP.d.cts

@@ -0,0 +1,227 @@
+import { Schema } from "effect";
+//#region ../schema/src/domain/eval-validations.d.ts
+declare const ValidationValue: Schema.Struct<{
+  text: Schema.filter<typeof Schema.String>;
+  format: Schema.Literal<["text", "json"]>;
+  state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+  truncated: typeof Schema.Boolean;
+}>;
+type ValidationValue = typeof ValidationValue.Type;
+declare const ValidationCall: Schema.Struct<{
+  index: Schema.refine<number, typeof Schema.NonNegative>;
+  method: Schema.Literal<["answer", "transcript", "turns", "readText", "exists", "exec", "cli.calls", "api.calls", "api.url", "mcp.calls"]>;
+  startedAt: typeof Schema.Number;
+  durationMs: Schema.NullOr<Schema.refine<number, typeof Schema.NonNegative>>;
+  input: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  output: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  error: Schema.NullOr<Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>>;
+}>;
+type ValidationCall = typeof ValidationCall.Type;
+declare const EvalValidation: Schema.Struct<{
+  id: Schema.filter<Schema.filter<typeof Schema.String>>;
+  index: Schema.refine<number, typeof Schema.NonNegative>;
+  name: Schema.filter<typeof Schema.String>;
+  kind: Schema.Literal<["code", "judge", "command"]>;
+  status: Schema.Literal<["queued", "running", "passed", "failed", "error", "skipped"]>;
+  startedAt: Schema.NullOr<typeof Schema.Number>;
+  durationMs: Schema.NullOr<Schema.refine<number, typeof Schema.NonNegative>>;
+  message: Schema.filter<typeof Schema.String>;
+  exitCode: Schema.NullOr<typeof Schema.Int>;
+  truncated: typeof Schema.Boolean;
+  judgment: Schema.optional<Schema.Struct<{
+    name: typeof Schema.String;
+    model: typeof Schema.String;
+    evaluator: typeof Schema.String;
+    score: Schema.NullOr<Schema.filter<typeof Schema.Number>>;
+    choice: Schema.NullOr<typeof Schema.String>;
+    reason: typeof Schema.String;
+    threshold: Schema.filter<typeof Schema.Number>;
+    durationMs: Schema.refine<number, typeof Schema.NonNegative>;
+    error: Schema.NullOr<typeof Schema.String>;
+    usage: Schema.optional<Schema.Struct<{
+      cacheReadTokens: typeof Schema.Int;
+      cacheWriteTokens: typeof Schema.Int;
+      cacheWrite1hTokens: Schema.optional<typeof Schema.Int>;
+      costUsd: Schema.optional<typeof Schema.Number>;
+      inputTokens: typeof Schema.Int;
+      outputTokens: typeof Schema.Int;
+      totalTokens: typeof Schema.Int;
+    }>>;
+  }>>;
+  input: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  output: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  error: Schema.NullOr<Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>>;
+  metadata: Schema.optional<Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>>;
+  calls: Schema.filter<Schema.Array$<Schema.Struct<{
+    index: Schema.refine<number, typeof Schema.NonNegative>;
+    method: Schema.Literal<["answer", "transcript", "turns", "readText", "exists", "exec", "cli.calls", "api.calls", "api.url", "mcp.calls"]>;
+    startedAt: typeof Schema.Number;
+    durationMs: Schema.NullOr<Schema.refine<number, typeof Schema.NonNegative>>;
+    input: Schema.Struct<{
+      text: Schema.filter<typeof Schema.String>;
+      format: Schema.Literal<["text", "json"]>;
+      state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+      truncated: typeof Schema.Boolean;
+    }>;
+    output: Schema.Struct<{
+      text: Schema.filter<typeof Schema.String>;
+      format: Schema.Literal<["text", "json"]>;
+      state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+      truncated: typeof Schema.Boolean;
+    }>;
+    error: Schema.NullOr<Schema.Struct<{
+      text: Schema.filter<typeof Schema.String>;
+      format: Schema.Literal<["text", "json"]>;
+      state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+      truncated: typeof Schema.Boolean;
+    }>>;
+  }>>>;
+  logs: Schema.filter<Schema.Array$<Schema.Struct<{
+    index: Schema.refine<number, typeof Schema.NonNegative>;
+    at: typeof Schema.Number;
+    level: Schema.Literal<["stdout", "stderr"]>;
+    value: Schema.Struct<{
+      text: Schema.filter<typeof Schema.String>;
+      format: Schema.Literal<["text", "json"]>;
+      state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+      truncated: typeof Schema.Boolean;
+    }>;
+  }>>>;
+}>;
+type EvalValidation = typeof EvalValidation.Type;
+//#endregion
+//#region ../schema/src/domain/api-mocks.d.ts
+declare const ApiCall_base: Schema.Class<ApiCall, {
+  api: typeof Schema.String;
+  index: Schema.refine<number, typeof Schema.NonNegative>;
+  method: typeof Schema.String;
+  path: typeof Schema.String;
+  matched: typeof Schema.Boolean;
+  startedAt: typeof Schema.Number;
+  durationMs: Schema.refine<number, typeof Schema.NonNegative>;
+  input: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  output: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  status: typeof Schema.Int;
+  error: Schema.NullOr<Schema.filter<typeof Schema.String>>;
+  logs: Schema.filter<Schema.Array$<Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>>>;
+}, Schema.Struct.Encoded<{
+  api: typeof Schema.String;
+  index: Schema.refine<number, typeof Schema.NonNegative>;
+  method: typeof Schema.String;
+  path: typeof Schema.String;
+  matched: typeof Schema.Boolean;
+  startedAt: typeof Schema.Number;
+  durationMs: Schema.refine<number, typeof Schema.NonNegative>;
+  input: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  output: Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>;
+  status: typeof Schema.Int;
+  error: Schema.NullOr<Schema.filter<typeof Schema.String>>;
+  logs: Schema.filter<Schema.Array$<Schema.Struct<{
+    text: Schema.filter<typeof Schema.String>;
+    format: Schema.Literal<["text", "json"]>;
+    state: Schema.Literal<["captured", "disabled", "unavailable"]>;
+    truncated: typeof Schema.Boolean;
+  }>>>;
+}>, never, {
+  readonly output: {
+    readonly text: string;
+    readonly format: "text" | "json";
+    readonly state: "captured" | "disabled" | "unavailable";
+    readonly truncated: boolean;
+  };
+} & {
+  readonly input: {
+    readonly text: string;
+    readonly format: "text" | "json";
+    readonly state: "captured" | "disabled" | "unavailable";
+    readonly truncated: boolean;
+  };
+} & {
+  readonly api: string;
+} & {
+  readonly path: string;
+} & {
+  readonly method: string;
+} & {
+  readonly index: number;
+} & {
+  readonly matched: boolean;
+} & {
+  readonly startedAt: number;
+} & {
+  readonly durationMs: number;
+} & {
+  readonly status: number;
+} & {
+  readonly error: string | null;
+} & {
+  readonly logs: readonly {
+    readonly text: string;
+    readonly format: "text" | "json";
+    readonly state: "captured" | "disabled" | "unavailable";
+    readonly truncated: boolean;
+  }[];
+}, {}, {}>;
+declare class ApiCall extends ApiCall_base {}
+//#endregion
+export { ValidationValue as i, EvalValidation as n, ValidationCall as r, ApiCall as t };