@agjs/tsforge 0.1.16 → 0.1.18

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agjs/tsforge",
   "type": "module",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "license": "MIT",
   "description": "TypeScript coding harness with a deterministic gate, stack-aware guardrails, and stream-level correction.",
   "repository": {

package/src/inference/request.ts

@@ -68,17 +68,22 @@ function tokenCapField(cfg: IOpenAICompatibleConfig): Record<string, number> {
     : { max_tokens: max };
 }
 
-/** Tool-choice clamped for provider constraints: DeepSeek's thinking mode rejects
- *  `tool_choice: "required"`, so downgrade it to `"auto"` there. */
-function toolChoiceFor(
+/** The `tools` (+ `tool_choice`) request fields, with provider constraints
+ *  applied: DeepSeek's thinking mode rejects an explicit `tool_choice`, so omit
+ *  it entirely there (the model still gets the tools and decides). */
+function toolsBlock(
   cfg: IOpenAICompatibleConfig,
-  requested: "auto" | "required" | "none"
-): "auto" | "required" | "none" {
-  if (style(cfg) === "deepseek" && requested === "required") {
-    return "auto";
+  opts: ICompleteOptions
+): Record<string, unknown> {
+  if (opts.tools === undefined) {
+    return {};
   }
 
-  return requested;
+  if (style(cfg) === "deepseek") {
+    return { tools: opts.tools };
+  }
+
+  return { tools: opts.tools, tool_choice: opts.toolChoice ?? "auto" };
 }
 
 /** Build the request body object (pure). Field order keeps the qwen default
@@ -102,12 +107,7 @@ export function buildRequestBody(
     ...(cfg.repetitionPenalty === undefined
       ? {}
       : { repetition_penalty: cfg.repetitionPenalty }),
-    ...(opts.tools === undefined
-      ? {}
-      : {
-          tools: opts.tools,
-          tool_choice: toolChoiceFor(cfg, opts.toolChoice ?? "auto"),
-        }),
+    ...toolsBlock(cfg, opts),
     ...reasoningFields(cfg, opts),
     ...(streaming
       ? { stream: true, stream_options: { include_usage: true } }

package/src/loop/feedback/rule-docs.ts

@@ -139,6 +139,21 @@ const RULE_DOCS: Record<string, IRuleDoc> = {
     bad: "items.map((it, i) => <li key={i}>{it.text}</li>)",
     good: "items.map((it) => <li key={it.id}>{it.text}</li>)",
   },
+  "tsforge/no-jsx-computation": {
+    what: "No `.map()`/`.filter()`/arithmetic/chained logic inside JSX `{…}` — extract to a hook or pre-prep variable first.",
+    bad: "<ul>{items.filter((i) => i.visible).map((i) => <li key={i.id}>{i.label}</li>)}</ul>",
+    good: "const rows = useMemo(() => items.filter(...).map(...), [items]); return <ul>{rows}</ul>;",
+  },
+  "tsforge/no-state-in-component-body": {
+    what: "State hooks (`useState`, `useEffect`, `useMemo`, …) belong in `Component.hooks.ts`, not in the `.tsx` component body.",
+    bad: "export function Button() { const [open, setOpen] = useState(false); return <button />; }",
+    good: "export function useButton() { const [open, setOpen] = useState(false); return { open }; }",
+  },
+  "tsforge/no-inline-jsx-functions": {
+    what: "No inline arrow/function expressions in JSX attributes — bind handlers in the hook and pass a reference.",
+    bad: "<button onClick={() => doThing(id)} />",
+    good: "const onClickRow = useCallback(() => doThing(id), [id]); <button onClick={onClickRow} />",
+  },
 };
 
 /**

package/src/loop/rule-docs.generated.json

@@ -359,6 +359,16 @@
     "bad": "// Example that violates the rule",
     "good": "// Corrected version"
   },
+  "tsforge/no-jsx-computation": {
+    "what": "Move complex computations out of JSX into hooks or helper functions",
+    "bad": "// Example that violates the rule",
+    "good": "// Corrected version"
+  },
+  "tsforge/no-state-in-component-body": {
+    "what": "State hooks must be in .hooks.ts files, not directly in components",
+    "bad": "// Example that violates the rule",
+    "good": "// Corrected version"
+  },
   "tsforge/mask-pii-fields": {
     "what": "Disallow unmasked PII (email, phone, password, token, ...) in structured-logger payloads — the #1 way data leaks quietly.",
     "bad": "// Example that violates the rule",

package/src/rule-packs/react-component-architecture/index.ts

@@ -6,6 +6,8 @@ import { indexMustReexportDefaultRule } from "./rules/index-must-reexport-defaul
 import { maxHooksPerFileRule } from "./rules/max-hooks-per-file";
 import { noCrossFeatureImportsRule } from "./rules/no-cross-feature-imports";
 import { noInlineJsxFunctionsRule } from "./rules/no-inline-jsx-functions";
+import { noJsxComputationRule } from "./rules/no-jsx-computation";
+import { noStateInComponentBodyRule } from "./rules/no-state-in-component-body";
 import type { IRulePack } from "../rule-packs.types";
 
 const rules: Record<string, TSESLint.RuleModule<string, readonly unknown[]>> = {
@@ -15,6 +17,8 @@ const rules: Record<string, TSESLint.RuleModule<string, readonly unknown[]>> = {
   "max-hooks-per-file": maxHooksPerFileRule,
   "no-cross-feature-imports": noCrossFeatureImportsRule,
   "no-inline-jsx-functions": noInlineJsxFunctionsRule,
+  "no-jsx-computation": noJsxComputationRule,
+  "no-state-in-component-body": noStateInComponentBodyRule,
 };
 
 export const reactComponentArchitecturePack: IRulePack = {
@@ -29,6 +33,8 @@ export const reactComponentArchitecturePack: IRulePack = {
     "max-hooks-per-file": "warn",
     "no-cross-feature-imports": "error",
     "no-inline-jsx-functions": "warn",
+    "no-jsx-computation": "error",
+    "no-state-in-component-body": "error",
   },
 };
 

package/src/rule-packs/react-component-architecture/rules/no-jsx-computation.ts

@@ -0,0 +1,110 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import type { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+import { createRule } from "../../create-rule";
+import { isStoryFile } from "../utils";
+
+export const RULE_NAME = "no-jsx-computation";
+
+export interface INoJsxComputationOptions {
+  readonly allowSimpleTernary?: boolean;
+}
+
+type RuleOptions = [INoJsxComputationOptions];
+type MessageIds = "noComputation" | "noChainedLogic";
+
+const ARRAY_METHODS = ["map", "filter", "reduce", "sort", "find"];
+const ARITHMETIC_OPERATORS = ["+", "-", "*", "/"];
+
+const optionSchema: JSONSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allowSimpleTernary: {
+      type: "boolean",
+    },
+  },
+};
+
+export const noJsxComputationRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Move complex computations out of JSX into hooks or helper functions",
+    },
+    schema: [optionSchema],
+    messages: {
+      noComputation: "Extract this computation into a hook or helper function",
+      noChainedLogic:
+        "Complex logical expressions should be extracted into variables or hooks",
+    },
+  },
+  defaultOptions: [{ allowSimpleTernary: true }],
+  create(context, [options]) {
+    const filename = context.filename;
+
+    if (isStoryFile(filename)) {
+      return {};
+    }
+
+    const allowSimpleTernary = options.allowSimpleTernary ?? true;
+
+    return {
+      "JSXExpressionContainer > CallExpression"(node: TSESTree.CallExpression) {
+        if (node.callee.type === AST_NODE_TYPES.MemberExpression) {
+          const prop = node.callee.property;
+
+          if (
+            prop.type === AST_NODE_TYPES.Identifier &&
+            ARRAY_METHODS.includes(prop.name)
+          ) {
+            context.report({
+              node,
+              messageId: "noComputation",
+            });
+          }
+        }
+      },
+      "JSXExpressionContainer > ConditionalExpression"(
+        node: TSESTree.ConditionalExpression
+      ) {
+        if (!allowSimpleTernary) {
+          context.report({
+            node,
+            messageId: "noComputation",
+          });
+        }
+      },
+      "JSXExpressionContainer > LogicalExpression"(
+        node: TSESTree.LogicalExpression
+      ) {
+        let depth = 0;
+        let current: TSESTree.Node = node;
+
+        while (current.type === AST_NODE_TYPES.LogicalExpression) {
+          depth += 1;
+          current = current.left;
+        }
+
+        if (depth > 1) {
+          context.report({
+            node,
+            messageId: "noChainedLogic",
+          });
+        }
+      },
+      "JSXExpressionContainer > BinaryExpression"(
+        node: TSESTree.BinaryExpression
+      ) {
+        if (ARITHMETIC_OPERATORS.includes(node.operator)) {
+          context.report({
+            node,
+            messageId: "noComputation",
+          });
+        }
+      },
+    };
+  },
+});

package/src/rule-packs/react-component-architecture/rules/no-state-in-component-body.ts

@@ -0,0 +1,114 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import type { JSONSchema4 } from "@typescript-eslint/utils/json-schema";
+
+import { createRule } from "../../create-rule";
+import {
+  isComponentFile,
+  isJsxReturningFunction,
+  isStoryFile,
+  isTestFile,
+} from "../utils";
+
+export const RULE_NAME = "no-state-in-component-body";
+
+const REACT_HOOKS = [
+  "useState",
+  "useReducer",
+  "useEffect",
+  "useMemo",
+  "useCallback",
+  "useLayoutEffect",
+  "useRef",
+];
+
+const DEFAULT_ALLOWED_HOOKS = ["useId", "useTransition", "useDeferredValue"];
+
+export interface INoStateInComponentBodyOptions {
+  readonly allowedHooks?: readonly string[];
+}
+
+type RuleOptions = [INoStateInComponentBodyOptions];
+type MessageIds = "noStateInComponent";
+
+const optionSchema: JSONSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allowedHooks: {
+      type: "array",
+      items: { type: "string" },
+    },
+  },
+};
+
+export const noStateInComponentBodyRule = createRule<RuleOptions, MessageIds>({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "State hooks must be in .hooks.ts files, not directly in components",
+    },
+    schema: [optionSchema],
+    messages: {
+      noStateInComponent:
+        "Hook '{{hookName}}' must be in a custom hook (.hooks.ts), not in component body",
+    },
+  },
+  defaultOptions: [{ allowedHooks: DEFAULT_ALLOWED_HOOKS }],
+  create(context, [options]) {
+    const filename = context.filename;
+
+    if (!isComponentFile(filename)) {
+      return {};
+    }
+
+    if (isStoryFile(filename) || isTestFile(filename)) {
+      return {};
+    }
+
+    const allowedHooks = new Set(options.allowedHooks ?? DEFAULT_ALLOWED_HOOKS);
+
+    return {
+      CallExpression(node: TSESTree.CallExpression) {
+        if (node.callee.type !== AST_NODE_TYPES.Identifier) {
+          return;
+        }
+
+        const hookName = node.callee.name;
+
+        if (!REACT_HOOKS.includes(hookName)) {
+          return;
+        }
+
+        if (allowedHooks.has(hookName)) {
+          return;
+        }
+
+        let parent: TSESTree.Node | undefined = node.parent;
+        let inComponent = false;
+
+        while (parent) {
+          if (
+            (parent.type === AST_NODE_TYPES.FunctionDeclaration ||
+              parent.type === AST_NODE_TYPES.ArrowFunctionExpression) &&
+            isJsxReturningFunction(parent)
+          ) {
+            inComponent = true;
+            break;
+          }
+
+          parent = parent.parent;
+        }
+
+        if (inComponent) {
+          context.report({
+            node,
+            messageId: "noStateInComponent",
+            data: { hookName },
+          });
+        }
+      },
+    };
+  },
+});

package/src/rule-packs/react-component-architecture/utils.ts

@@ -1,3 +1,5 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+
 /**
  * Detect if a file is a component file (.tsx with uppercase name, not test/story)
  */
@@ -22,6 +24,57 @@ export function isStoryFile(filename: string): boolean {
   return filename.includes(".stories.tsx");
 }
 
+/**
+ * Detect if a file is a test file
+ */
+export function isTestFile(filename: string): boolean {
+  return filename.includes(".test.ts") || filename.includes(".test.tsx");
+}
+
+/**
+ * True when a function returns JSX directly or via a block `return`.
+ */
+export function isJsxReturningFunction(
+  node: TSESTree.FunctionDeclaration | TSESTree.ArrowFunctionExpression
+): boolean {
+  const fnBody = node.body;
+
+  if (!fnBody) {
+    return false;
+  }
+
+  if (
+    fnBody.type === AST_NODE_TYPES.JSXElement ||
+    fnBody.type === AST_NODE_TYPES.JSXFragment
+  ) {
+    return true;
+  }
+
+  if (fnBody.type === AST_NODE_TYPES.BlockStatement) {
+    return containsReturnOfJsx(fnBody);
+  }
+
+  return false;
+}
+
+function containsReturnOfJsx(block: TSESTree.BlockStatement): boolean {
+  for (const stmt of block.body) {
+    if (stmt.type === AST_NODE_TYPES.ReturnStatement) {
+      const arg = stmt.argument;
+
+      if (
+        arg &&
+        (arg.type === AST_NODE_TYPES.JSXElement ||
+          arg.type === AST_NODE_TYPES.JSXFragment)
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
 /**
  * Detect if path is in shadcn/ui components folder
  */