td-ai-tools 1.2.10 → 1.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "td-ai-tools",
-  "version": "1.2.10",
+  "version": "1.2.11",
   "description": "Install agent skills and packs into your project",
   "type": "module",
   "scripts": {

package/skills/shopify-lint/eslint-plugin-theory/src/build.test.ts

@@ -0,0 +1,21 @@
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+import { describe, expect, it } from 'vitest';
+
+const run = promisify(execFile);
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+describe('the published build', () => {
+  // `npm install` runs `npm run build` for this plugin, so a type error here
+  // breaks setup for every consumer of the shopify-lint skill.
+  it('typechecks under the build config', async () => {
+    const result = await run('npx', ['tsc', '-p', 'tsconfig.build.json', '--noEmit'], {
+      cwd: packageRoot,
+    }).catch((error: { stdout?: string; stderr?: string }) => error);
+
+    expect([result.stdout, result.stderr].filter(Boolean).join('\n')).toBe('');
+  }, 120_000);
+});

package/skills/shopify-lint/eslint-plugin-theory/src/rules/require-jsdoc.test.ts

@@ -13,6 +13,7 @@ describe('require-jsdoc', () => {
         '/** A component. */\nconst Hero = class extends HTMLElement {};',
         '/** Add two values.\n * @param {number} a First value.\n * @param {number} b Second value.\n * @returns {number} Their sum.\n */\nfunction add(a, b) { return a + b; }',
         '/** Run setup.\n * @returns {void}\n */\nconst setup = () => {};',
+        '/** Run setup.\n * @param {number} times How many times.\n * @returns {void}\n */\nconst setup = function (times) {};',
         '/** A component. */\nclass Hero { constructor() {}\n/** Open it.\n * @param {boolean} animated Whether to animate.\n * @returns {void}\n */\nopen(animated) {} }',
       ],
       invalid: [
@@ -25,7 +26,12 @@ describe('require-jsdoc', () => {
           code: '/** Run it.\n * @param value Value.\n * @returns Result.\n */\nconst run = (value) => value;',
           errors: [{ messageId: 'params' }, { messageId: 'returns' }],
         },
+        {
+          code: 'const setup = function (times) {};',
+          errors: [{ messageId: 'missing', data: { kind: 'function' } }],
+        },
         { code: 'class Hero {}', errors: [{ messageId: 'missing', data: { kind: 'class' } }] },
+        { code: 'const Hero = class extends HTMLElement {};', errors: [{ messageId: 'missing', data: { kind: 'class' } }] },
         {
           code: '/** A component. */\nclass Hero { open() {} }',
           errors: [{ messageId: 'missing', data: { kind: 'function' } }],

package/skills/shopify-lint/eslint-plugin-theory/src/rules/require-jsdoc.ts

@@ -1,5 +1,16 @@
 import type { Rule, SourceCode } from 'eslint';
-import type { Comment, Node } from 'estree';
+import type {
+  ArrowFunctionExpression,
+  ClassExpression,
+  Comment,
+  FunctionExpression,
+  Node,
+} from 'estree';
+
+// Selector keys such as `'VariableDeclarator > FunctionExpression.init'` fall
+// through `RuleListener`'s index signature, so their `node` needs an explicit
+// type. The visited node is the initializer, hence it always has a parent.
+type Visited<T> = T & Rule.NodeParentExtension;
 
 function jsdocFor(node: Rule.Node, sourceCode: SourceCode): Comment | undefined {
   const comment = sourceCode.getCommentsBefore(node as Node).at(-1);
@@ -20,6 +31,11 @@ function typedTags(comment: Comment, tag: 'param' | 'returns' | 'return'): numbe
   return [...comment.value.matchAll(expression)].length;
 }
 
+/** Walks from a `const x = <function|class>` initializer to its declaration statement. */
+function declarationOf(node: Rule.Node): Rule.Node {
+  return (node.parent as Rule.Node).parent as Rule.Node;
+}
+
 /** Require documented, explicitly typed named JavaScript declarations. */
 export const requireJsdoc: Rule.RuleModule = {
   meta: {
@@ -46,11 +62,11 @@ export const requireJsdoc: Rule.RuleModule = {
       return comment;
     }
 
-    function checkFunction(node: Rule.Node & { params?: unknown[] }, reportNode: Rule.Node = node) {
+    function checkFunction(fn: { params?: unknown[] }, reportNode: Rule.Node) {
       const comment = checkDocumented(reportNode, 'function');
       if (!comment) return;
 
-      const expected = node.params?.length ?? 0;
+      const expected = fn.params?.length ?? 0;
       if (typedTags(comment, 'param') < expected) {
         context.report({ node: reportNode, messageId: 'params', data: { expected: String(expected) } });
       }
@@ -63,17 +79,17 @@ export const requireJsdoc: Rule.RuleModule = {
       ClassDeclaration(node) {
         checkDocumented(node, 'class');
       },
-      'VariableDeclarator > ClassExpression.init'(node) {
-        checkDocumented(node.parent.parent as Rule.Node, 'class');
+      'VariableDeclarator > ClassExpression.init'(node: Visited<ClassExpression>) {
+        checkDocumented(declarationOf(node), 'class');
       },
       FunctionDeclaration(node) {
-        checkFunction(node);
+        checkFunction(node, node);
       },
-      'VariableDeclarator > ArrowFunctionExpression.init'(node) {
-        checkFunction(node, node.parent.parent as Rule.Node);
+      'VariableDeclarator > ArrowFunctionExpression.init'(node: Visited<ArrowFunctionExpression>) {
+        checkFunction(node, declarationOf(node));
       },
-      'VariableDeclarator > FunctionExpression.init'(node) {
-        checkFunction(node, node.parent.parent as Rule.Node);
+      'VariableDeclarator > FunctionExpression.init'(node: Visited<FunctionExpression>) {
+        checkFunction(node, declarationOf(node));
       },
       MethodDefinition(node) {
         if (node.kind !== 'constructor') {