@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-subagents/test/unit/writer-budget-guidance.test.ts

@@ -1,25 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { describe, it } from "node:test";
-
-const readProjectFile = (file: string): string => readFileSync(join(process.cwd(), file), "utf-8");
-
-describe("writer budget guidance", () => {
-	it("keeps hard tool and usage caps off mutation-capable workers", () => {
-		const toolReference = readProjectFile("docs/tool-reference.md");
-		const skill = readProjectFile("skills/pi-subagents/SKILL.md");
-		const reviewLoop = readProjectFile("prompts/review-loop.md");
-
-		for (const text of [toolReference, skill, reviewLoop]) {
-			assert.match(text, /As a conservative orchestration policy, do not (?:pass|set) a hard `toolBudget`/);
-			assert.match(text, /default tool budget blocks read\/search tools rather than mutation tools/i);
-			assert.match(text, /checkpoint after the current tool returns/);
-			assert.match(text, /changed files/);
-			assert.match(text, /build\/test state/);
-			assert.match(text, /commit or PR state/);
-		}
-		assert.match(toolReference, /elapsed timeout is not a mutation-safe boundary/i);
-	});
-
-});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/effect/index.ts

@@ -1,13 +0,0 @@
-import { eslintCompatPlugin } from "@oxlint/plugins";
-
-import { noServiceConstructorImportsRule } from "./rules/no-service-constructor-imports.ts";
-
-/** Opt-in Oxlint rules for Effect service and Layer architecture. */
-const antiSlopEffectPlugin = eslintCompatPlugin({
-	meta: { name: "anti-slop-effect" },
-	rules: {
-		"no-service-constructor-imports": noServiceConstructorImportsRule,
-	},
-});
-
-export default antiSlopEffectPlugin;

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/effect/rules/no-service-constructor-imports.ts

@@ -1,52 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-
-import type { ESTree } from "@oxlint/plugins";
-
-const SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
-const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
-
-function isProjectLocalImport(source: string): boolean {
-	return source.startsWith("./") || source.startsWith("../");
-}
-
-function getImportedName(specifier: ESTree.ImportSpecifier): string {
-	if (specifier.imported.type === "Identifier") return specifier.imported.name;
-	return specifier.imported.value;
-}
-
-/** Keep dependency-bearing Effect service constructors local to their owning capability modules. */
-export const noServiceConstructorImportsRule = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow project-local make<CapabilityName> imports outside test and spec files.",
-		},
-		messages: {
-			serviceConstructorImport:
-				'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
-		},
-	},
-	create(context) {
-		const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
-
-		return {
-			ImportDeclaration(node) {
-				if (isTestFile || !isProjectLocalImport(node.source.value)) return;
-
-				for (const specifier of node.specifiers) {
-					if (specifier.type !== "ImportSpecifier") continue;
-
-					const importedName = getImportedName(specifier);
-					if (!SERVICE_CONSTRUCTOR_NAME.test(importedName)) continue;
-
-					context.report({
-						node: specifier,
-						messageId: "serviceConstructorImport",
-						data: { name: importedName },
-					});
-				}
-			},
-		};
-	},
-});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/index.ts

@@ -1,41 +0,0 @@
-import { eslintCompatPlugin } from "@oxlint/plugins";
-
-import { noChainedTypeAssertionsRule } from "./rules/no-chained-type-assertions.ts";
-import { noConditionalEmptyObjectSpreadRule } from "./rules/no-conditional-empty-object-spread.ts";
-import { noKnownValueWideningRule } from "./rules/no-known-value-widening.ts";
-import { noModuleMockingRule } from "./rules/no-module-mocking.ts";
-import { noObjectParametersRule } from "./rules/no-object-parameters.ts";
-import { noReflectApplyRule } from "./rules/no-reflect-apply.ts";
-import { noReflectGetRule } from "./rules/no-reflect-get.ts";
-import { noRuntimeTypeofRule } from "./rules/no-runtime-typeof.ts";
-import { noForbiddenTermInSymbolNamesRule } from "./rules/no-shape-in-symbol-names.ts";
-import { noUnknownParametersRule } from "./rules/no-unknown-parameters.ts";
-import { noUnknownReturnsRule } from "./rules/no-unknown-returns.ts";
-import { noUnknownTypeAliasesRule } from "./rules/no-unknown-type-aliases.ts";
-import { noUnsafeDictionaryTypeRule } from "./rules/no-unsafe-dictionary-type.ts";
-import { noWidenThenAssertRule } from "./rules/no-widen-then-assert.ts";
-import { requireSafetyCommentForTypeAssertionRule } from "./rules/require-safety-comment-for-type-assertion.ts";
-
-/** Generic Oxlint rules that reject low-evidence and low-signal implementation patterns. */
-const antiSlopPlugin = eslintCompatPlugin({
-	meta: { name: "anti-slop" },
-	rules: {
-		"no-chained-type-assertions": noChainedTypeAssertionsRule,
-		"no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
-		"no-known-value-widening": noKnownValueWideningRule,
-		"no-module-mocking": noModuleMockingRule,
-		"no-object-parameters": noObjectParametersRule,
-		"no-reflect-apply": noReflectApplyRule,
-		"no-reflect-get": noReflectGetRule,
-		"no-runtime-typeof": noRuntimeTypeofRule,
-		"no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
-		"no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
-		"no-unknown-parameters": noUnknownParametersRule,
-		"no-unknown-returns": noUnknownReturnsRule,
-		"no-unknown-type-aliases": noUnknownTypeAliasesRule,
-		"no-widen-then-assert": noWidenThenAssertRule,
-		"require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule,
-	},
-});
-
-export default antiSlopPlugin;

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/rules/no-chained-type-assertions.ts

@@ -1,77 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-import type { ESTree } from "@oxlint/plugins";
-
-type TypeAssertionExpression = ESTree.TSAsExpression | ESTree.TSTypeAssertion;
-
-function isTypeAssertionExpression(node: ESTree.Node): node is TypeAssertionExpression {
-  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
-}
-
-function unwrapParenthesizedExpression(expression: ESTree.Expression): ESTree.Expression {
-  let current = expression;
-  while (current.type === "ParenthesizedExpression") {
-    current = current.expression;
-  }
-  return current;
-}
-
-function isConstAssertion(node: TypeAssertionExpression): boolean {
-  const { typeAnnotation } = node;
-  return (
-    typeAnnotation.type === "TSTypeReference" &&
-    typeAnnotation.typeName.type === "Identifier" &&
-    typeAnnotation.typeName.name === "const"
-  );
-}
-
-function isOutermostAssertionInChain(node: TypeAssertionExpression): boolean {
-  let current: ESTree.Expression = node;
-  let parent = node.parent;
-
-  while (parent.type === "ParenthesizedExpression" && parent.expression === current) {
-    current = parent;
-    parent = parent.parent;
-  }
-
-  return !isTypeAssertionExpression(parent) || parent.expression !== current;
-}
-
-function isForbiddenAssertionChain(node: TypeAssertionExpression): boolean {
-  let assertionCount = 0;
-  let hasNonConstAssertion = false;
-  let current: ESTree.Expression = node;
-
-  while (isTypeAssertionExpression(current)) {
-    assertionCount += 1;
-    hasNonConstAssertion ||= !isConstAssertion(current);
-    current = unwrapParenthesizedExpression(current.expression);
-  }
-
-  return assertionCount > 1 && hasNonConstAssertion;
-}
-
-/** Disallow nested TypeScript type assertions, while permitting chains made only of const assertions. */
-export const noChainedTypeAssertionsRule = defineRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains.",
-    },
-    messages: {
-      chained:
-        "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it.",
-    },
-  },
-  createOnce(context) {
-    const checkTypeAssertion = (node: TypeAssertionExpression) => {
-      if (!isOutermostAssertionInChain(node) || !isForbiddenAssertionChain(node)) return;
-      context.report({ node, messageId: "chained" });
-    };
-
-    return {
-      TSAsExpression: checkTypeAssertion,
-      TSTypeAssertion: checkTypeAssertion,
-    };
-  },
-});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/rules/no-conditional-empty-object-spread.ts

@@ -1,49 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-import type { ESTree } from "@oxlint/plugins";
-
-function unwrapParentheses(node: ESTree.Expression): ESTree.Expression {
-  let current = node;
-  while (current.type === "ParenthesizedExpression") {
-    current = current.expression;
-  }
-  return current;
-}
-
-function isEmptyObjectExpression(node: ESTree.Expression): boolean {
-  return node.type === "ObjectExpression" && node.properties.length === 0;
-}
-
-function isConditionalEmptyObjectSpread(node: ESTree.Expression): boolean {
-  const conditional = unwrapParentheses(node);
-  return (
-    conditional.type === "ConditionalExpression" &&
-    (isEmptyObjectExpression(conditional.consequent) ||
-      isEmptyObjectExpression(conditional.alternate))
-  );
-}
-
-/** Ban conditional empty-object spreads without changing their omission semantics. */
-export const noConditionalEmptyObjectSpreadRule = defineRule({
-  meta: {
-    type: "suggestion",
-    docs: {
-      description:
-        "Disallow object spreads that conditionally spread an empty object to omit fields.",
-    },
-    messages: {
-      avoid:
-        "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present.",
-    },
-  },
-  createOnce(context) {
-    return {
-      SpreadElement(node) {
-        if (node.parent.type !== "ObjectExpression") return;
-
-        if (isConditionalEmptyObjectSpread(node.argument)) {
-          context.report({ node, messageId: "avoid" });
-        }
-      },
-    };
-  },
-});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/rules/no-known-value-widening.ts

@@ -1,247 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-
-import {
-	classifyWideningTarget,
-	createTypeEnvironment,
-	isKnownEvidenceExpression,
-	type TypeEnvironment,
-	type WideningTarget,
-} from "../shared/dictionary-types.ts";
-
-import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
-
-type FunctionExpression = ESTree.ArrowFunctionExpression | ESTree.Function;
-
-function unwrapExpression(expression: ESTree.Expression): ESTree.Expression {
-	let current = expression;
-	while (
-		current.type === "ParenthesizedExpression" ||
-		current.type === "TSAsExpression" ||
-		current.type === "TSSatisfiesExpression" ||
-		current.type === "TSTypeAssertion" ||
-		current.type === "TSNonNullExpression"
-	) {
-		current = current.expression;
-	}
-	return current;
-}
-
-function resolveVariable(
-	sourceCode: SourceCode,
-	identifier: ESTree.IdentifierReference,
-): Variable | null {
-	let scope: Scope | null = sourceCode.getScope(identifier);
-	while (scope !== null) {
-		const variable = scope.set.get(identifier.name);
-		if (variable !== undefined) return variable;
-		scope = scope.upper;
-	}
-	return null;
-}
-
-function variableDeclarator(variable: Variable): ESTree.VariableDeclarator | null {
-	if (variable.defs.length !== 1) return null;
-	const [definition] = variable.defs;
-	return definition?.type === "Variable" && definition.node.type === "VariableDeclarator"
-		? definition.node
-		: null;
-}
-
-function isStableConstVariable(variable: Variable, declarator: ESTree.VariableDeclarator): boolean {
-	return (
-		declarator.parent.type === "VariableDeclaration" &&
-		declarator.parent.kind === "const" &&
-		variable.references.every((reference) => reference.init || !reference.isWrite())
-	);
-}
-
-function hasKnownEvidence(
-	sourceCode: SourceCode,
-	expression: ESTree.Expression,
-	visitedVariables = new Set<Variable>(),
-): boolean {
-	if (isKnownEvidenceExpression(expression)) return true;
-	const unwrapped = unwrapExpression(expression);
-	if (unwrapped.type !== "Identifier") return false;
-	const variable = resolveVariable(sourceCode, unwrapped);
-	if (variable === null || visitedVariables.has(variable)) return false;
-	const declarator = variableDeclarator(variable);
-	if (
-		declarator === null ||
-		declarator.init === null ||
-		!isStableConstVariable(variable, declarator)
-	) {
-		return false;
-	}
-	visitedVariables.add(variable);
-	return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
-}
-
-function annotationTarget(
-	annotation: ESTree.TSTypeAnnotation | null | undefined,
-	environment: TypeEnvironment,
-): WideningTarget | null {
-	return annotation === null || annotation === undefined
-		? null
-		: classifyWideningTarget(annotation.typeAnnotation, environment);
-}
-
-function enclosingFunction(node: ESTree.Node): FunctionExpression | null {
-	let current: ESTree.Node | null = node.parent;
-	while (current !== null && current.type !== "Program") {
-		if (
-			current.type === "ArrowFunctionExpression" ||
-			current.type === "FunctionDeclaration" ||
-			current.type === "FunctionExpression"
-		) {
-			return current;
-		}
-		current = current.parent;
-	}
-	return null;
-}
-
-function sourceKeyName(sourceCode: SourceCode, key: ESTree.PropertyKey): string {
-	if (key.type === "Identifier" || key.type === "PrivateIdentifier") return key.name;
-	if (key.type === "Literal") return String(key.value);
-	return sourceCode.getText(key);
-}
-
-function functionName(sourceCode: SourceCode, owner: FunctionExpression | null): string {
-	if (owner === null) return "anonymous function";
-	if (owner.id !== null) return owner.id.name;
-	const parent = owner.parent;
-	if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier")
-		return parent.id.name;
-	if (parent.type === "MethodDefinition") return sourceKeyName(sourceCode, parent.key);
-	return "anonymous function";
-}
-
-function isEmptyObjectExpression(expression: ESTree.Expression): boolean {
-	const unwrapped = unwrapExpression(expression);
-	return unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0;
-}
-
-function isDictionaryAccumulatorTarget(destination: WideningTarget): boolean {
-	return destination.kind === "open dictionary" || destination.kind === "generic container";
-}
-
-function hasParentAssertion(node: ESTree.Node): boolean {
-	return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
-}
-
-/** Detect sound syntactic cases where a known value is explicitly widened and loses evidence. */
-export const noKnownValueWideningRule = defineRule({
-	meta: {
-		type: "problem",
-		docs: {
-			description:
-				"Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence.",
-		},
-		messages: {
-			widening:
-				"The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract.",
-		},
-	},
-	createOnce(context) {
-		let environment: TypeEnvironment | null = null;
-
-		const reportFlow = (
-			expression: ESTree.Expression,
-			destination: WideningTarget | null,
-			subject: string,
-		) => {
-			if (destination === null) return;
-			if (
-				isDictionaryAccumulatorTarget(destination) &&
-				isEmptyObjectExpression(expression)
-			) {
-				return;
-			}
-			if (!hasKnownEvidence(context.sourceCode, expression)) return;
-			context.report({
-				node: expression,
-				messageId: "widening",
-				data: { subject, target: destination.kind },
-			});
-		};
-
-		const targetFromAnnotation = (annotation: ESTree.TSTypeAnnotation | null | undefined) =>
-			environment === null ? null : annotationTarget(annotation, environment);
-
-		return {
-			Program(node) {
-				environment = createTypeEnvironment(node);
-			},
-			VariableDeclarator(node) {
-				if (node.init === null || node.id.type !== "Identifier") return;
-				reportFlow(
-					node.init,
-					targetFromAnnotation(node.id.typeAnnotation),
-					`binding \`${node.id.name}\``,
-				);
-			},
-			PropertyDefinition(node) {
-				if (node.value === null) return;
-				reportFlow(
-					node.value,
-					targetFromAnnotation(node.typeAnnotation),
-					`property \`${sourceKeyName(context.sourceCode, node.key)}\``,
-				);
-			},
-			AccessorProperty(node) {
-				if (node.value === null) return;
-				reportFlow(
-					node.value,
-					targetFromAnnotation(node.typeAnnotation),
-					`property \`${sourceKeyName(context.sourceCode, node.key)}\``,
-				);
-			},
-			AssignmentExpression(node) {
-				if (node.operator !== "=" || node.left.type !== "Identifier") return;
-				const variable = resolveVariable(context.sourceCode, node.left);
-				if (variable === null) return;
-				const declarator = variableDeclarator(variable);
-				if (declarator === null || declarator.id.type !== "Identifier") return;
-				reportFlow(
-					node.right,
-					targetFromAnnotation(declarator.id.typeAnnotation),
-					`binding \`${declarator.id.name}\``,
-				);
-			},
-			ReturnStatement(node) {
-				if (node.argument === null) return;
-				const owner = enclosingFunction(node);
-				reportFlow(
-					node.argument,
-					targetFromAnnotation(owner?.returnType),
-					`return value of \`${functionName(context.sourceCode, owner)}\``,
-				);
-			},
-			ArrowFunctionExpression(node) {
-				if (node.body.type === "BlockStatement") return;
-				reportFlow(
-					node.body,
-					targetFromAnnotation(node.returnType),
-					`return value of \`${functionName(context.sourceCode, node)}\``,
-				);
-			},
-			TSAsExpression(node) {
-				if (environment === null || hasParentAssertion(node)) return;
-				reportFlow(
-					node.expression,
-					classifyWideningTarget(node.typeAnnotation, environment),
-					"assertion",
-				);
-			},
-			TSTypeAssertion(node) {
-				if (environment === null || hasParentAssertion(node)) return;
-				reportFlow(
-					node.expression,
-					classifyWideningTarget(node.typeAnnotation, environment),
-					"assertion",
-				);
-			},
-		};
-	},
-});

package/dist/extensions/pi-subagents/tools/oxlint/anti-slop/rules/no-module-mocking.ts

@@ -1,91 +0,0 @@
-import { defineRule } from "@oxlint/plugins";
-
-import type { ESTree, Scope, SourceCode, Variable } from "@oxlint/plugins";
-
-const moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
-
-function resolveVariable(
-  sourceCode: SourceCode,
-  identifier: ESTree.IdentifierReference,
-): Variable | null {
-  let scope: Scope | null = sourceCode.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== undefined) return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
-
-function importedName(node: ESTree.Node): string | null {
-  if (node.type !== "ImportSpecifier") return null;
-  return node.imported.type === "Identifier" ? node.imported.name : node.imported.value;
-}
-
-function isTestFrameworkObject(
-  sourceCode: SourceCode,
-  expression: ESTree.Expression,
-): expression is ESTree.IdentifierReference {
-  if (expression.type !== "Identifier") return false;
-  if (
-    (expression.name === "vi" || expression.name === "jest") &&
-    sourceCode.isGlobalReference(expression)
-  ) {
-    return true;
-  }
-
-  const variable = resolveVariable(sourceCode, expression);
-  if (variable === null || variable.defs.length === 0) {
-    return expression.name === "vi" || expression.name === "jest";
-  }
-  return variable.defs.some((definition) => {
-    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
-      return false;
-    }
-    const source = definition.parent.source.value;
-    const name = importedName(definition.node);
-    return (source === "vitest" && name === "vi") || (source === "@jest/globals" && name === "jest");
-  });
-}
-
-function moduleMockCall(sourceCode: SourceCode, callee: ESTree.Expression): boolean {
-  if (!("property" in callee) || !("object" in callee) || !("computed" in callee)) return false;
-  if (!isTestFrameworkObject(sourceCode, callee.object)) return false;
-  const property = callee.property;
-  const method = callee.computed
-    ? property.type === "Literal" &&
-      (property.value === "doMock" ||
-        property.value === "mock" ||
-        property.value === "unstable_mockModule")
-      ? property.value
-      : null
-    : property.type === "Identifier"
-      ? property.name
-      : null;
-  return method !== null && moduleMockMethods.has(method);
-}
-
-/** Ban test framework module mocking in favor of real dependency seams. */
-export const noModuleMockingRule = defineRule({
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces.",
-    },
-    messages: {
-      moduleMock:
-        "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
-    },
-  },
-  createOnce(context) {
-    return {
-      CallExpression(node) {
-        if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") return;
-        if (moduleMockCall(context.sourceCode, node.callee)) {
-          context.report({ node, messageId: "moduleMock" });
-        }
-      },
-    };
-  },
-});