@boyingliu01/xp-gate 0.10.1 → 0.10.3

package/build-integrity/__tests__/gate-10.test.ts

@@ -0,0 +1,230 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { runTscCheck, runPackCheck } from '../gate-10';
+
+// Increase test timeout for subprocess calls (tsc, npm pack)
+vi.setConfig({ testTimeout: 30000 });
+
+/**
+ * @test Gate 10 runTscCheck
+ * @intent Verify tsc --noEmit check behavior for build integrity gate
+ * @covers runTscCheck
+ */
+
+describe('runTscCheck', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gate10-test-'));
+    // Symlink node_modules from project root so tsc is available
+    const projectNodeModules = path.join(process.cwd(), 'node_modules');
+    const testNodeModules = path.join(tmpDir, 'node_modules');
+    try {
+      await fs.symlink(projectNodeModules, testNodeModules, 'dir');
+    } catch {
+      // Ignore if symlink fails (e.g., already exists)
+    }
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns skip when no tsconfig.json exists', async () => {
+    const result = await runTscCheck(tmpDir, 30000);
+    expect(result.status).toBe('skip');
+    expect(result.message).toContain('tsconfig.json');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns skip when tsc is not available on PATH', async () => {
+    // Create tsconfig.json but use a PATH without tsc
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({ compilerOptions: { strict: true } })
+    );
+
+    // Override PATH to exclude node_modules/.bin
+    const originalPath = process.env.PATH;
+    process.env.PATH = '/usr/bin:/bin';
+
+    try {
+      const result = await runTscCheck(tmpDir, 30000);
+      expect(result.status).toBe('skip');
+      expect(result.message).toContain('tsc');
+    } finally {
+      process.env.PATH = originalPath;
+    }
+  });
+
+  it('returns pass when tsc exits 0', async () => {
+    // Create a minimal valid TypeScript project
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          strict: true,
+          noEmit: true,
+        },
+        include: ['*.ts'],
+      })
+    );
+
+    await fs.writeFile(
+      path.join(tmpDir, 'valid.ts'),
+      'const x: number = 42;\nconsole.log(x);\n'
+    );
+
+    const result = await runTscCheck(tmpDir, 60000);
+    expect(result.status).toBe('pass');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns fail when tsc exits non-zero', async () => {
+    // Create a TypeScript project with type errors
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          strict: true,
+          noEmit: true,
+        },
+        include: ['*.ts'],
+      })
+    );
+
+    await fs.writeFile(
+      path.join(tmpDir, 'invalid.ts'),
+      'const x: number = "string";\n'
+    );
+
+    const result = await runTscCheck(tmpDir, 60000);
+    expect(result.status).toBe('fail');
+    expect(result.message).toMatch(/error|Error/);
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns skip when tsc times out', async () => {
+    // Create a large TypeScript project that will timeout
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          strict: true,
+          noEmit: true,
+        },
+        include: ['*.ts'],
+      })
+    );
+
+    // Create many files to slow down tsc
+    for (let i = 0; i < 100; i++) {
+      const content = `
+        export const value${i} = ${i};
+        export function fn${i}(): number { return ${i}; }
+        export interface Interface${i} { prop: number; }
+      `;
+      await fs.writeFile(path.join(tmpDir, `file${i}.ts`), content);
+    }
+
+    // Very short timeout to force timeout
+    const result = await runTscCheck(tmpDir, 500);
+    expect(result.status).toBe('skip');
+    expect(result.message).toMatch(/timeout|Timeout|TIMEOUT|timed out/);
+  });
+});
+
+/**
+ * @test Gate 10 runPackCheck
+ * @intent Verify npm pack --dry-run check behavior for build integrity gate
+ * @covers runPackCheck
+ */
+describe('runPackCheck', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'gate10-pack-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns skip when no package.json exists', async () => {
+    const result = await runPackCheck(tmpDir, 30000);
+    expect(result.status).toBe('skip');
+    expect(result.message).toContain('package.json');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns skip when package.json has no files field', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({ name: 'test-pkg', version: '1.0.0' })
+    );
+
+    const result = await runPackCheck(tmpDir, 30000);
+    expect(result.status).toBe('skip');
+    expect(result.message).toContain('files');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns pass when npm pack produces non-empty file list', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({
+        name: 'test-pkg',
+        version: '1.0.0',
+        files: ['index.js'],
+      })
+    );
+    await fs.writeFile(path.join(tmpDir, 'index.js'), 'module.exports = {};\n');
+
+    const result = await runPackCheck(tmpDir, 60000);
+    expect(result.status).toBe('pass');
+    expect(result.message).toMatch(/\d+ file/);
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns fail when npm pack exits non-zero', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({
+        name: 'test-pkg',
+        version: '1.0.0',
+        files: ['index.js'],
+        scripts: { prepack: 'exit 1' },
+      })
+    );
+    await fs.writeFile(path.join(tmpDir, 'index.js'), 'module.exports = {};\n');
+
+    const result = await runPackCheck(tmpDir, 60000);
+    expect(result.status).toBe('fail');
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('returns skip when npm pack times out', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'package.json'),
+      JSON.stringify({
+        name: 'test-pkg',
+        version: '1.0.0',
+        files: ['index.js'],
+      })
+    );
+    await fs.writeFile(path.join(tmpDir, 'index.js'), 'module.exports = {};\n');
+
+    const result = await runPackCheck(tmpDir, 1);
+    expect(result.status).toBe('skip');
+    expect(result.message).toMatch(/timeout|Timeout|TIMEOUT/);
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+});

package/build-integrity/__tests__/import-resolver.test.ts

@@ -0,0 +1,409 @@
+/**
+ * @test Gate 10 import resolver — extractImports, resolveImportPath, runImportCheck
+ * @intent Verify that relative imports are extracted, resolved, and checked against
+ *         the project boundary. Catches the original bug where tui-plugin.ts imported
+ *         ../../src/... which exists in the repo but not in the published npm package.
+ * @covers extractImports, resolveImportPath, runImportCheck
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { extractImports, resolveImportPath, runImportCheck } from '../gate-10';
+
+/**
+ * ─── extractImports ────────────────────────────────────────────────────────────
+ */
+describe('extractImports', () => {
+  it('extracts named import with single quotes', () => {
+    const content = `import { foo } from './bar';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts default import', () => {
+    const content = `import foo from './bar';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts namespace import', () => {
+    const content = `import * as foo from './bar';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts require() call', () => {
+    const content = `const foo = require('./bar');`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts dynamic import()', () => {
+    const content = `const foo = import('./bar');`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts named export from', () => {
+    const content = `export { foo } from './bar';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts star export from', () => {
+    const content = `export * from './bar';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('extracts multiple imports from multiple lines', () => {
+    const content = [
+      `import { a } from './a';`,
+      `import b from './b';`,
+      `const c = require('./c');`,
+      `export * from './d';`,
+    ].join('\n');
+    const result = extractImports(content);
+    expect(result).toEqual([
+      { path: './a', line: 1 },
+      { path: './b', line: 2 },
+      { path: './c', line: 3 },
+      { path: './d', line: 4 },
+    ]);
+  });
+
+  it('skips bare npm package imports', () => {
+    const content = [
+      `import { foo } from 'lodash';`,
+      `import path from 'path';`,
+      `import { bar } from './local';`,
+    ].join('\n');
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './local', line: 3 }]);
+  });
+
+  it('skips node: protocol imports', () => {
+    const content = [
+      `import fs from 'node:fs';`,
+      `import { readFile } from 'node:fs/promises';`,
+      `import { bar } from './local';`,
+    ].join('\n');
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './local', line: 3 }]);
+  });
+
+  it('handles double-quoted import paths', () => {
+    const content = `import { foo } from "./bar";`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar', line: 1 }]);
+  });
+
+  it('handles parent-relative imports', () => {
+    const content = `import { foo } from '../parent/bar';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: '../parent/bar', line: 1 }]);
+  });
+
+  it('handles deeply nested relative imports', () => {
+    const content = `import { foo } from '../../../deep/path';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: '../../../deep/path', line: 1 }]);
+  });
+
+  it('returns empty array for content with no imports', () => {
+    const content = `const x = 42;\nconsole.log(x);`;
+    const result = extractImports(content);
+    expect(result).toEqual([]);
+  });
+
+  it('handles import with .js extension', () => {
+    const content = `import { foo } from './bar.js';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './bar.js', line: 1 }]);
+  });
+
+  it('handles side-effect import', () => {
+    const content = `import './side-effect';`;
+    const result = extractImports(content);
+    expect(result).toEqual([{ path: './side-effect', line: 1 }]);
+  });
+});
+
+/**
+ * ─── resolveImportPath ─────────────────────────────────────────────────────────
+ */
+describe('resolveImportPath', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'import-resolver-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns null for bare npm package imports', () => {
+    const result = resolveImportPath('lodash', '/some/file.ts');
+    expect(result).toBeNull();
+  });
+
+  it('returns null for node: protocol imports', () => {
+    const result = resolveImportPath('node:fs', '/some/file.ts');
+    expect(result).toBeNull();
+  });
+
+  it('resolves relative import to existing .ts file', async () => {
+    const targetFile = path.join(tmpDir, 'bar.ts');
+    await fs.writeFile(targetFile, 'export const x = 1;');
+
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./bar', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('resolves relative import to existing .tsx file', async () => {
+    const targetFile = path.join(tmpDir, 'component.tsx');
+    await fs.writeFile(targetFile, 'export const X = () => null;');
+
+    const fromFile = path.join(tmpDir, 'app.ts');
+    const result = resolveImportPath('./component', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('resolves relative import to existing .js file', async () => {
+    const targetFile = path.join(tmpDir, 'util.js');
+    await fs.writeFile(targetFile, 'module.exports = {};');
+
+    const fromFile = path.join(tmpDir, 'main.ts');
+    const result = resolveImportPath('./util', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('resolves relative import with explicit .js extension to .ts file', async () => {
+    // TypeScript allows `import './bar.js'` to resolve to `bar.ts`
+    const targetFile = path.join(tmpDir, 'bar.ts');
+    await fs.writeFile(targetFile, 'export const x = 1;');
+
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./bar.js', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('resolves relative import to index.ts in directory', async () => {
+    const subDir = path.join(tmpDir, 'mydir');
+    await fs.mkdir(subDir);
+    const indexFile = path.join(subDir, 'index.ts');
+    await fs.writeFile(indexFile, 'export const x = 1;');
+
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./mydir', fromFile);
+    expect(result).toBe(indexFile);
+  });
+
+  it('resolves relative import to index.js in directory', async () => {
+    const subDir = path.join(tmpDir, 'mydir');
+    await fs.mkdir(subDir);
+    const indexFile = path.join(subDir, 'index.js');
+    await fs.writeFile(indexFile, 'module.exports = {};');
+
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./mydir', fromFile);
+    expect(result).toBe(indexFile);
+  });
+
+  it('resolves parent-relative import', async () => {
+    const subDir = path.join(tmpDir, 'sub');
+    await fs.mkdir(subDir);
+    const targetFile = path.join(tmpDir, 'bar.ts');
+    await fs.writeFile(targetFile, 'export const x = 1;');
+
+    const fromFile = path.join(subDir, 'foo.ts');
+    const result = resolveImportPath('../bar', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('returns null when target file does not exist', () => {
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./nonexistent', fromFile);
+    expect(result).toBeNull();
+  });
+
+  it('resolves import with .mjs extension', async () => {
+    const targetFile = path.join(tmpDir, 'mod.mjs');
+    await fs.writeFile(targetFile, 'export const x = 1;');
+
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./mod.mjs', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('resolves import with .cjs extension', async () => {
+    const targetFile = path.join(tmpDir, 'mod.cjs');
+    await fs.writeFile(targetFile, 'module.exports = {};');
+
+    const fromFile = path.join(tmpDir, 'foo.ts');
+    const result = resolveImportPath('./mod.cjs', fromFile);
+    expect(result).toBe(targetFile);
+  });
+
+  it('resolves import with .jsx extension', async () => {
+    const targetFile = path.join(tmpDir, 'comp.jsx');
+    await fs.writeFile(targetFile, 'export default function() { return null; }');
+
+    const fromFile = path.join(tmpDir, 'app.ts');
+    const result = resolveImportPath('./comp', fromFile);
+    expect(result).toBe(targetFile);
+  });
+});
+
+/**
+ * ─── runImportCheck ────────────────────────────────────────────────────────────
+ */
+describe('runImportCheck', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'import-check-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns pass when all relative imports resolve within project', async () => {
+    // Create project structure
+    const srcDir = path.join(tmpDir, 'src');
+    await fs.mkdir(srcDir);
+
+    const barFile = path.join(srcDir, 'bar.ts');
+    await fs.writeFile(barFile, 'export const x = 1;');
+
+    const fooFile = path.join(srcDir, 'foo.ts');
+    await fs.writeFile(fooFile, `import { x } from './bar';\nconsole.log(x);\n`);
+
+    const result = await runImportCheck([fooFile], tmpDir, 30000);
+    expect(result.status).toBe('pass');
+    expect(result.violations).toEqual([]);
+  });
+
+  it('returns fail when import resolves outside project root (original bug)', async () => {
+    // Simulate the original bug: a deeply nested file imports a path that
+    // resolves outside the project root. From pkg/dist/sub/, the import
+    // ../../../../outside escapes tmpDir (the project root).
+    const nestedDir = path.join(tmpDir, 'pkg', 'dist', 'sub');
+    await fs.mkdir(nestedDir, { recursive: true });
+
+    const badFile = path.join(nestedDir, 'file.ts');
+    await fs.writeFile(
+      badFile,
+      `import { x } from '../../../../outside';\n`
+    );
+
+    const result = await runImportCheck([badFile], tmpDir, 30000);
+    expect(result.status).toBe('fail');
+    expect(result.violations.length).toBeGreaterThan(0);
+    expect(result.violations[0].reason).toMatch(/escapes|outside|boundary/i);
+  });
+
+  it('returns fail when imported file does not exist', async () => {
+    const srcDir = path.join(tmpDir, 'src');
+    await fs.mkdir(srcDir);
+
+    const fooFile = path.join(srcDir, 'foo.ts');
+    await fs.writeFile(fooFile, `import { x } from './nonexistent';\n`);
+
+    const result = await runImportCheck([fooFile], tmpDir, 30000);
+    expect(result.status).toBe('fail');
+    expect(result.violations.length).toBeGreaterThan(0);
+    expect(result.violations[0].reason).toMatch(/not found|does not exist|missing/i);
+  });
+
+  it('returns pass when only bare npm imports are used', async () => {
+    const srcDir = path.join(tmpDir, 'src');
+    await fs.mkdir(srcDir);
+
+    const fooFile = path.join(srcDir, 'foo.ts');
+    await fs.writeFile(
+      fooFile,
+      `import path from 'path';\nimport fs from 'node:fs';\nimport _ from 'lodash';\n`
+    );
+
+    const result = await runImportCheck([fooFile], tmpDir, 30000);
+    expect(result.status).toBe('pass');
+    expect(result.violations).toEqual([]);
+  });
+
+  it('returns pass when no changed files are provided', async () => {
+    const result = await runImportCheck([], tmpDir, 30000);
+    expect(result.status).toBe('pass');
+    expect(result.violations).toEqual([]);
+  });
+
+  it('checks multiple changed files', async () => {
+    const srcDir = path.join(tmpDir, 'src');
+    await fs.mkdir(srcDir);
+
+    const barFile = path.join(srcDir, 'bar.ts');
+    await fs.writeFile(barFile, 'export const x = 1;');
+
+    const goodFile = path.join(srcDir, 'good.ts');
+    await fs.writeFile(goodFile, `import { x } from './bar';\n`);
+
+    const badFile = path.join(srcDir, 'bad.ts');
+    await fs.writeFile(badFile, `import { y } from './missing';\n`);
+
+    const result = await runImportCheck([goodFile, badFile], tmpDir, 30000);
+    expect(result.status).toBe('fail');
+    expect(result.violations.length).toBe(1);
+    expect(result.violations[0].file).toBe(badFile);
+  });
+
+  it('skips files that do not exist on disk', async () => {
+    const result = await runImportCheck(['/nonexistent/file.ts'], tmpDir, 30000);
+    expect(result.status).toBe('pass');
+    expect(result.violations).toEqual([]);
+  });
+
+  it('reports correct line number for violation', async () => {
+    const srcDir = path.join(tmpDir, 'src');
+    await fs.mkdir(srcDir);
+
+    const fooFile = path.join(srcDir, 'foo.ts');
+    await fs.writeFile(
+      fooFile,
+      [`const x = 1;`, `const y = 2;`, `import { z } from './missing';`, `console.log(x, y);`].join('\n')
+    );
+
+    const result = await runImportCheck([fooFile], tmpDir, 30000);
+    expect(result.status).toBe('fail');
+    expect(result.violations[0].line).toBe(3);
+  });
+
+  it('handles import with explicit .js extension resolving to .ts', async () => {
+    const srcDir = path.join(tmpDir, 'src');
+    await fs.mkdir(srcDir);
+
+    const barFile = path.join(srcDir, 'bar.ts');
+    await fs.writeFile(barFile, 'export const x = 1;');
+
+    const fooFile = path.join(srcDir, 'foo.ts');
+    await fs.writeFile(fooFile, `import { x } from './bar.js';\n`);
+
+    const result = await runImportCheck([fooFile], tmpDir, 30000);
+    expect(result.status).toBe('pass');
+    expect(result.violations).toEqual([]);
+  });
+
+  it('includes durationMs in result', async () => {
+    const result = await runImportCheck([], tmpDir, 30000);
+    expect(result.durationMs).toBeGreaterThanOrEqual(0);
+  });
+
+  it('includes message in result', async () => {
+    const result = await runImportCheck([], tmpDir, 30000);
+    expect(typeof result.message).toBe('string');
+  });
+});