@starklab/stark-mcp 0.1.0

package/src/adopt/wrapperResolver.test.js

@@ -0,0 +1,324 @@
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { describe, it, expect, afterEach } from 'vitest';
+
+import { resolveWrappers } from './wrapperResolver.js';
+
+let tmpDirs = [];
+
+afterEach(() => {
+  for (const dir of tmpDirs) rmSync(dir, { recursive: true, force: true });
+  tmpDirs = [];
+});
+
+function fixture(files) {
+  const root = mkdtempSync(path.join(os.tmpdir(), 'stark-adopt-wrap-'));
+  tmpDirs.push(root);
+  for (const [rel, content] of Object.entries(files)) {
+    const full = path.join(root, rel);
+    mkdirSync(path.dirname(full), { recursive: true });
+    writeFileSync(full, content);
+  }
+  return root;
+}
+
+function wrapper(result, exportedAs) {
+  const found = result.wrappers.find((w) => w.exportedAs === exportedAs);
+  if (!found) throw new Error(`No wrapper "${exportedAs}" in result. Found: ${result.wrappers.map((w) => w.exportedAs).join(', ')}`);
+  return found;
+}
+
+describe('resolveWrappers — faithfulness classification', () => {
+  it('classifies a pure passthrough wrapper as transparent', () => {
+    const root = fixture({
+      'src/MyButton.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function MyButton(props) {
+          return <Button {...props} />;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    const w = wrapper(result, 'MyButton');
+    expect(w.terminal).toBe('ds-component');
+    expect(w.component).toBe('Button');
+    expect(w.chain[0].faithfulness).toBe('transparent');
+    expect(w.depth).toBe(1);
+  });
+
+  it('classifies a hardcoded prop as constraining, even alongside a spread', () => {
+    const root = fixture({
+      'src/MyButton.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function MyButton(props) {
+          return <Button {...props} variant="primary" />;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(wrapper(result, 'MyButton').chain[0].faithfulness).toBe('constraining');
+  });
+
+  it('classifies a className/style override as divergent, ranked above constraining', () => {
+    const root = fixture({
+      'src/MyButton.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function MyButton(props) {
+          return <Button {...props} variant="primary" className="custom-look" />;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(wrapper(result, 'MyButton').chain[0].faithfulness).toBe('divergent');
+  });
+
+  it('classifies a native wrapper around a single DS-bearing child as augmenting', () => {
+    const root = fixture({
+      'src/FormField.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function FormField() {
+          return (
+            <div className="field">
+              <Button variant="primary">Save</Button>
+            </div>
+          );
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    const w = wrapper(result, 'FormField');
+    expect(w.terminal).toBe('ds-component');
+    expect(w.component).toBe('Button');
+    expect(w.chain[0].faithfulness).toBe('augmenting');
+  });
+});
+
+describe('resolveWrappers — terminal classification', () => {
+  it('does not report a native-only wrapper (no DS component reachable) as a wrapper', () => {
+    const root = fixture({
+      'src/Plain.jsx': `
+        export function Plain() {
+          return <div className="plain">hello</div>;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(result.wrappers.find((w) => w.exportedAs === 'Plain')).toBeUndefined();
+  });
+
+  it('does not report a third-party-only wrapper as a wrapper', () => {
+    const root = fixture({
+      'src/MyThing.jsx': `
+        import { Box } from 'some-other-lib';
+        export function MyThing() {
+          return <Box>hi</Box>;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(result.wrappers.find((w) => w.exportedAs === 'MyThing')).toBeUndefined();
+  });
+
+  it('never crashes or reports a wrapper for a circular local wrapper chain', () => {
+    const root = fixture({
+      'src/CycleA.jsx': `
+        import { CycleB } from './CycleB.jsx';
+        export function CycleA(props) { return <CycleB {...props} />; }
+      `,
+      'src/CycleB.jsx': `
+        import { CycleA } from './CycleA.jsx';
+        export function CycleB(props) { return <CycleA {...props} />; }
+      `,
+    });
+    expect(() => resolveWrappers(root, { platform: 'web' })).not.toThrow();
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(result.wrappers.find((w) => w.exportedAs === 'CycleA')).toBeUndefined();
+    expect(result.wrappers.find((w) => w.exportedAs === 'CycleB')).toBeUndefined();
+  });
+});
+
+describe('resolveWrappers — cross-file recursive chains', () => {
+  it('follows a wrapper-of-a-wrapper chain across files down to the DS terminal', () => {
+    const root = fixture({
+      'src/ButtonB.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function ButtonB(props) {
+          return <Button {...props} />;
+        }
+      `,
+      'src/ButtonA.jsx': `
+        import { ButtonB } from './ButtonB.jsx';
+        export function ButtonA(props) {
+          return <ButtonB {...props} />;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    const a = wrapper(result, 'ButtonA');
+    const b = wrapper(result, 'ButtonB');
+    expect(a.component).toBe('Button');
+    expect(a.depth).toBe(2);
+    expect(b.component).toBe('Button');
+    expect(b.depth).toBe(1);
+  });
+});
+
+describe('resolveWrappers — fanout counting', () => {
+  it('excludes a parent wrapper’s internal reference from the child wrapper’s own fanout', () => {
+    const root = fixture({
+      'src/ButtonB.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function ButtonB(props) {
+          return <Button {...props} />;
+        }
+      `,
+      'src/ButtonA.jsx': `
+        import { ButtonB } from './ButtonB.jsx';
+        export function ButtonA(props) {
+          return <ButtonB {...props} />;
+        }
+      `,
+      'src/App.jsx': `
+        import { ButtonA } from './ButtonA.jsx';
+        import { ButtonB } from './ButtonB.jsx';
+        export const App = () => (
+          <div>
+            <ButtonA />
+            <ButtonA />
+            <ButtonB />
+          </div>
+        );
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    const a = wrapper(result, 'ButtonA');
+    const b = wrapper(result, 'ButtonB');
+    // App.jsx uses ButtonA twice and ButtonB once directly; ButtonA's own
+    // internal <ButtonB/> render must not inflate ButtonB's fanout.
+    expect(a.fanout.counts.jsx).toBe(2);
+    expect(b.fanout.counts.jsx).toBe(1);
+  });
+});
+
+describe('resolveWrappers — dominion.config.json declared wrappers', () => {
+  it('fills in a wrapper auto-detection could not resolve', () => {
+    const root = fixture({
+      'src/DynamicThing.jsx': `
+        import React from 'react';
+        import { Button } from '@starklab/stk-components';
+        const Impl = Button;
+        export function DynamicThing(props) {
+          return React.createElement(Impl, props);
+        }
+      `,
+      'dominion.config.json': JSON.stringify({ wrappers: { './src/DynamicThing.jsx': 'Button' } }),
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(result.dominionConfigFound).toBe(true);
+    const w = wrapper(result, 'DynamicThing');
+    expect(w.component).toBe('Button');
+    expect(w.provenance).toBe('declared');
+  });
+
+  it('keeps the auto-detected terminal and reports a contradiction when the declaration disagrees', () => {
+    const root = fixture({
+      'src/MyButton.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function MyButton(props) {
+          return <Button {...props} />;
+        }
+      `,
+      'dominion.config.json': JSON.stringify({ wrappers: { './src/MyButton.jsx': 'BadgeStatus' } }),
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    const w = wrapper(result, 'MyButton');
+    expect(w.component).toBe('Button'); // auto-detected wins, not overridden
+    expect(result.contradictions).toHaveLength(1);
+    expect(result.contradictions[0]).toMatchObject({ declaredAs: 'BadgeStatus', autoDetected: 'Button' });
+  });
+
+  it('reports an unresolved declaration when the configured file does not exist', () => {
+    const root = fixture({
+      'src/App.jsx': `export const App = () => null;`,
+      'dominion.config.json': JSON.stringify({ wrappers: { './src/Nope.jsx': 'Button' } }),
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(result.unresolvedDeclarations).toHaveLength(1);
+    expect(result.unresolvedDeclarations[0].reason).toBe('file-not-found');
+  });
+});
+
+describe('resolveWrappers — cross-workspace resolution (ADOPTION_APP_PLAN.md §3e)', () => {
+  it('resolves a workspace-sibling import into its own source instead of stopping at third-party', () => {
+    const siblingDir = fixture({
+      'package.json': JSON.stringify({ name: '@acme/ui', main: 'src/index.js' }),
+      'src/index.js': `export { Wrapper } from './Wrapper.jsx';`,
+      'src/Wrapper.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function Wrapper(props) {
+          return <Button {...props} />;
+        }
+      `,
+    });
+    const root = fixture({
+      'src/App.jsx': `
+        import { Wrapper } from '@acme/ui';
+        export function AppWrapper(props) {
+          return <Wrapper {...props} />;
+        }
+      `,
+    });
+
+    const withoutWorkspace = resolveWrappers(root, { platform: 'web' });
+    expect(withoutWorkspace.wrappers.find((w) => w.exportedAs === 'AppWrapper')).toBeUndefined();
+
+    const workspacePackages = new Map([['@acme/ui', siblingDir]]);
+    const withWorkspace = resolveWrappers(root, { platform: 'web', workspacePackages });
+    const w = wrapper(withWorkspace, 'AppWrapper');
+    expect(w.terminal).toBe('ds-component');
+    expect(w.component).toBe('Button');
+    // AppWrapper (root) wraps Wrapper (sibling package) wraps Button — a
+    // genuine two-hop chain, same as the same-repo cross-file case above.
+    expect(w.depth).toBe(2);
+  });
+
+  it('does not treat a package importing its own name as a crossing', () => {
+    const root = fixture({
+      'package.json': JSON.stringify({ name: '@acme/self', main: 'src/index.js' }),
+      'src/index.js': `export { Local } from './Local.jsx';`,
+      'src/Local.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function Local(props) {
+          return <Button {...props} />;
+        }
+      `,
+    });
+    const workspacePackages = new Map([['@acme/self', root]]);
+    expect(() => resolveWrappers(root, { platform: 'web', workspacePackages })).not.toThrow();
+    const result = resolveWrappers(root, { platform: 'web', workspacePackages });
+    const w = wrapper(result, 'Local');
+    expect(w.terminal).toBe('ds-component');
+    expect(w.component).toBe('Button');
+  });
+});
+
+describe('resolveWrappers — byComponent rollup', () => {
+  it('left-joins wrappers onto the full catalog', () => {
+    const root = fixture({
+      'src/MyButton.jsx': `
+        import { Button } from '@starklab/stk-components';
+        export function MyButton(props) {
+          return <Button {...props} />;
+        }
+      `,
+    });
+    const result = resolveWrappers(root, { platform: 'web' });
+    expect(result.byComponent.length).toBeGreaterThan(50);
+    const button = result.byComponent.find((c) => c.name === 'Button');
+    expect(button.viaWrappers).toHaveLength(1);
+    const accordion = result.byComponent.find((c) => c.name === 'Accordion');
+    expect(accordion.viaWrappers).toHaveLength(0);
+  });
+});