octocode-cli 1.2.5 → 1.2.7

package/skills/octocode-code-engineer/src/collectors/security.ts

@@ -0,0 +1,309 @@
+import * as ts from 'typescript';
+
+import { getLineAndCharacter } from '../common/utils.js';
+
+import type { CodeLocation, ConsoleLogEntry, FileEntry, SuspiciousString } from '../types/index.js';
+
+const SENSITIVE_LOG_PATTERNS = [
+  /password/i,
+  /passwd/i,
+  /\bsecret\b/i,
+  /\btoken\b/i,
+  /\bauth\b/i,
+  /credential/i,
+  /credit.?card/i,
+  /\bssn\b/i,
+  /social.?security/i,
+  /api[_-]?key/i,
+  /private[_-]?key/i,
+  /access[_-]?key/i,
+  /\bsession\b/i,
+];
+
+const CONSOLE_LOG_METHODS = new Set([
+  'log', 'debug', 'trace', 'info', 'warn', 'error', 'dir', 'table',
+]);
+
+const SECRET_PATTERNS = [
+  /password\s*[:=]\s*['"`]/i,
+  /api[_-]?key\s*[:=]\s*['"`]/i,
+  /secret\s*[:=]\s*['"`]/i,
+  /token\s*[:=]\s*['"`]/i,
+  /-----BEGIN.*KEY/,
+  /private[_-]?key\s*[:=]\s*['"`]/i,
+  /auth[_-]?token\s*[:=]\s*['"`]/i,
+];
+
+const SQL_KEYWORDS =
+  /\b(SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|TRUNCATE)\b/i;
+
+/** Strings that look like placeholders, not real secrets */
+const PLACEHOLDER_PATTERN = /^(YOUR_|REPLACE_ME|<[a-z_-]+>|\$\{|{{)/i;
+/** UUID pattern: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx */
+const UUID_PATTERN =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function isInsideRegexLiteral(node: ts.Node): boolean {
+  let current: ts.Node | undefined = node.parent;
+  while (current) {
+    if (ts.isRegularExpressionLiteral(current)) return true;
+    if (
+      ts.isNewExpression(current) &&
+      current.expression.getText(node.getSourceFile()) === 'RegExp'
+    )
+      return true;
+    current = current.parent;
+  }
+  return false;
+}
+
+function isPlaceholderOrUuid(value: string): boolean {
+  return PLACEHOLDER_PATTERN.test(value) || UUID_PATTERN.test(value);
+}
+
+/** Skip strings inside finding metadata fields (suggestedFix, reason, impact, etc.) */
+const METADATA_PROP_NAMES = new Set([
+  'suggestedFix',
+  'strategy',
+  'steps',
+  'reason',
+  'impact',
+  'expectedResult',
+  'title',
+]);
+
+function isInsideMetadataProperty(node: ts.Node): boolean {
+  let current: ts.Node | undefined = node.parent;
+  while (current) {
+    if (ts.isPropertyAssignment(current) && ts.isIdentifier(current.name)) {
+      if (METADATA_PROP_NAMES.has(current.name.text)) return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function computeShannonEntropy(s: string): number {
+  const freq = new Map<string, number>();
+  for (const ch of s) freq.set(ch, (freq.get(ch) || 0) + 1);
+  let entropy = 0;
+  for (const count of freq.values()) {
+    const p = count / s.length;
+    if (p > 0) entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+
+export function collectSecurityData(
+  sourceFile: ts.SourceFile,
+  fileRelative: string,
+  fileEntry: FileEntry
+): void {
+  const evalUsages: CodeLocation[] = [];
+  const unsafeHtmlAssignments: CodeLocation[] = [];
+  const suspiciousStrings: SuspiciousString[] = [];
+  const consoleLogs: ConsoleLogEntry[] = [];
+  const regexLiterals: Array<{
+    lineStart: number;
+    lineEnd: number;
+    pattern: string;
+  }> = [];
+
+  const visit = (node: ts.Node): void => {
+    if (ts.isDebuggerStatement(node)) {
+      const loc = getLineAndCharacter(sourceFile, node);
+      consoleLogs.push({
+        method: 'debugger',
+        lineStart: loc.lineStart,
+        lineEnd: loc.lineEnd,
+        hasSensitiveArg: false,
+      });
+    }
+
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isPropertyAccessExpression(expr)) {
+        const obj = expr.expression.getText(sourceFile);
+        const method = expr.name.getText(sourceFile);
+        if (obj === 'console' && CONSOLE_LOG_METHODS.has(method)) {
+          const loc = getLineAndCharacter(sourceFile, node);
+          const argText = node.arguments.map(a => a.getText(sourceFile)).join(' ');
+          const hasSensitiveArg = SENSITIVE_LOG_PATTERNS.some(p => p.test(argText));
+          consoleLogs.push({
+            method,
+            lineStart: loc.lineStart,
+            lineEnd: loc.lineEnd,
+            hasSensitiveArg,
+            argSnippet: argText.slice(0, 80),
+          });
+        }
+      }
+    }
+
+    if (ts.isCallExpression(node)) {
+      const text = node.expression.getText(sourceFile);
+      if (text === 'eval' || text === 'Function') {
+        const loc = getLineAndCharacter(sourceFile, node);
+        evalUsages.push({
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+      if (text === 'new Function') {
+        const loc = getLineAndCharacter(sourceFile, node);
+        evalUsages.push({
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+      if (
+        (text === 'setTimeout' || text === 'setInterval') &&
+        node.arguments.length > 0
+      ) {
+        const firstArg = node.arguments[0];
+        if (
+          ts.isStringLiteral(firstArg) ||
+          ts.isNoSubstitutionTemplateLiteral(firstArg)
+        ) {
+          const loc = getLineAndCharacter(sourceFile, node);
+          evalUsages.push({
+            file: fileRelative,
+            lineStart: loc.lineStart,
+            lineEnd: loc.lineEnd,
+          });
+        }
+      }
+      if (text === 'document.write' || text === 'document.writeln') {
+        const loc = getLineAndCharacter(sourceFile, node);
+        unsafeHtmlAssignments.push({
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+    }
+
+    if (
+      ts.isNewExpression(node) &&
+      node.expression.getText(sourceFile) === 'Function'
+    ) {
+      const loc = getLineAndCharacter(sourceFile, node);
+      evalUsages.push({
+        file: fileRelative,
+        lineStart: loc.lineStart,
+        lineEnd: loc.lineEnd,
+      });
+    }
+
+    if (
+      ts.isBinaryExpression(node) &&
+      node.operatorToken.kind === ts.SyntaxKind.EqualsToken
+    ) {
+      if (ts.isPropertyAccessExpression(node.left)) {
+        const prop = node.left.name.getText(sourceFile);
+        if (prop === 'innerHTML' || prop === 'outerHTML') {
+          const loc = getLineAndCharacter(sourceFile, node);
+          unsafeHtmlAssignments.push({
+            file: fileRelative,
+            lineStart: loc.lineStart,
+            lineEnd: loc.lineEnd,
+          });
+        }
+      }
+    }
+
+    if (
+      ts.isJsxAttribute(node) &&
+      node.name.getText(sourceFile) === 'dangerouslySetInnerHTML'
+    ) {
+      const loc = getLineAndCharacter(sourceFile, node);
+      unsafeHtmlAssignments.push({
+        file: fileRelative,
+        lineStart: loc.lineStart,
+        lineEnd: loc.lineEnd,
+      });
+    }
+
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      if (!isInsideMetadataProperty(node) && !isInsideRegexLiteral(node)) {
+        const value = node.text;
+        if (!isPlaceholderOrUuid(value)) {
+          for (const pattern of SECRET_PATTERNS) {
+            if (pattern.test(value)) {
+              const loc = getLineAndCharacter(sourceFile, node);
+              suspiciousStrings.push({
+                lineStart: loc.lineStart,
+                lineEnd: loc.lineEnd,
+                kind: 'hardcoded-secret',
+                snippet: value.slice(0, 40),
+                context: 'literal',
+              });
+              break;
+            }
+          }
+          if (value.length >= 20 && computeShannonEntropy(value) > 4.5) {
+            const loc = getLineAndCharacter(sourceFile, node);
+            suspiciousStrings.push({
+              lineStart: loc.lineStart,
+              lineEnd: loc.lineEnd,
+              kind: 'hardcoded-secret',
+              context: 'literal',
+            });
+          }
+        }
+      }
+    }
+
+    if (ts.isRegularExpressionLiteral(node)) {
+      const regexText = node.getText(sourceFile);
+      for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(regexText)) {
+          const loc = getLineAndCharacter(sourceFile, node);
+          suspiciousStrings.push({
+            lineStart: loc.lineStart,
+            lineEnd: loc.lineEnd,
+            kind: 'hardcoded-secret',
+            snippet: regexText.slice(0, 40),
+            context: 'regex-definition',
+          });
+          break;
+        }
+      }
+    }
+
+    if (ts.isTemplateExpression(node)) {
+      if (!isInsideMetadataProperty(node)) {
+        const fullText = node.getText(sourceFile);
+        if (SQL_KEYWORDS.test(fullText) && node.templateSpans.length > 0) {
+          const loc = getLineAndCharacter(sourceFile, node);
+          suspiciousStrings.push({
+            lineStart: loc.lineStart,
+            lineEnd: loc.lineEnd,
+            kind: 'sql-injection',
+            snippet: fullText.slice(0, 60),
+          });
+        }
+      }
+    }
+
+    if (ts.isRegularExpressionLiteral(node)) {
+      const pattern = node.text;
+      const loc = getLineAndCharacter(sourceFile, node);
+      regexLiterals.push({
+        lineStart: loc.lineStart,
+        lineEnd: loc.lineEnd,
+        pattern,
+      });
+    }
+
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+
+  fileEntry.evalUsages = evalUsages;
+  fileEntry.unsafeHtmlAssignments = unsafeHtmlAssignments;
+  fileEntry.suspiciousStrings = suspiciousStrings;
+  fileEntry.consoleLogs = consoleLogs;
+  fileEntry.regexLiterals = regexLiterals;
+}

package/skills/octocode-code-engineer/src/collectors/test-profile.test.ts

@@ -0,0 +1,97 @@
+import * as ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+
+import { collectTestProfile } from './test-profile.js';
+
+import type { FileEntry } from '../types/index.js';
+
+function parse(
+  code: string,
+  fileName = '/repo/src/test.spec.ts'
+): ts.SourceFile {
+  return ts.createSourceFile(fileName, code, ts.ScriptTarget.ESNext, true);
+}
+
+function emptyFileEntry(): FileEntry {
+  return {
+    package: 'test',
+    file: 'test.spec.ts',
+    parseEngine: 'typescript',
+    nodeCount: 0,
+    kindCounts: {},
+    functions: [],
+    flows: [],
+    dependencyProfile: {
+      internalDependencies: [],
+      externalDependencies: [],
+      unresolvedDependencies: [],
+      declaredExports: [],
+      importedSymbols: [],
+      reExports: [],
+    },
+  };
+}
+
+describe('collectTestProfile', () => {
+  it('describe + it blocks → detects test blocks', () => {
+    const code = `describe('suite', () => { it('test', () => {}); });`;
+    const sourceFile = parse(code);
+    const fileEntry = emptyFileEntry();
+    collectTestProfile(sourceFile, 'test.spec.ts', fileEntry);
+    expect(fileEntry.testProfile).toBeDefined();
+    expect(fileEntry.testProfile!.testBlocks).toHaveLength(1);
+    expect(fileEntry.testProfile!.testBlocks[0].name).toBe('test');
+  });
+
+  it('expect().toBe() → detects assertions', () => {
+    const code = `it('asserts', () => { expect(1).toBe(1); });`;
+    const sourceFile = parse(code);
+    const fileEntry = emptyFileEntry();
+    collectTestProfile(sourceFile, 'test.spec.ts', fileEntry);
+    expect(fileEntry.testProfile).toBeDefined();
+    expect(fileEntry.testProfile!.testBlocks).toHaveLength(1);
+    expect(fileEntry.testProfile!.testBlocks[0].assertionCount).toBeGreaterThan(
+      0
+    );
+  });
+
+  it('jest.mock() → detects mocks', () => {
+    const code = `jest.mock('./module'); describe('suite', () => { it('test', () => {}); });`;
+    const sourceFile = parse(code);
+    const fileEntry = emptyFileEntry();
+    collectTestProfile(sourceFile, 'test.spec.ts', fileEntry);
+    expect(fileEntry.testProfile).toBeDefined();
+    expect(fileEntry.testProfile!.mockCalls).toHaveLength(1);
+  });
+
+  it('vi.spyOn() → detects spy', () => {
+    const code = `const obj = { method: () => {} }; describe('suite', () => { it('test', () => { vi.spyOn(obj, 'method'); }); });`;
+    const sourceFile = parse(code);
+    const fileEntry = emptyFileEntry();
+    collectTestProfile(sourceFile, 'test.spec.ts', fileEntry);
+    expect(fileEntry.testProfile).toBeDefined();
+    expect(fileEntry.testProfile!.spyOrStubCalls).toHaveLength(1);
+    expect(fileEntry.testProfile!.spyOrStubCalls[0].kind).toBe('spy');
+  });
+
+  it('beforeEach → detects setup hooks', () => {
+    const code = `describe('suite', () => { beforeEach(() => {}); it('test', () => {}); });`;
+    const sourceFile = parse(code);
+    const fileEntry = emptyFileEntry();
+    collectTestProfile(sourceFile, 'test.spec.ts', fileEntry);
+    expect(fileEntry.testProfile).toBeDefined();
+    expect(fileEntry.testProfile!.setupCalls).toHaveLength(1);
+    expect(fileEntry.testProfile!.setupCalls[0].kind).toBe('beforeEach');
+  });
+
+  it('no test profile for non-test code', () => {
+    const code = `function add(a: number, b: number) { return a + b; }`;
+    const sourceFile = parse(code);
+    const fileEntry = emptyFileEntry();
+    collectTestProfile(sourceFile, 'util.ts', fileEntry);
+    expect(fileEntry.testProfile).toBeDefined();
+    expect(fileEntry.testProfile!.testBlocks).toHaveLength(0);
+    expect(fileEntry.testProfile!.mockCalls).toHaveLength(0);
+    expect(fileEntry.testProfile!.setupCalls).toHaveLength(0);
+  });
+});

package/skills/octocode-code-engineer/src/collectors/test-profile.ts

@@ -0,0 +1,269 @@
+import * as ts from 'typescript';
+
+import { getLineAndCharacter } from '../common/utils.js';
+
+import type {
+  CodeLocation,
+  FileEntry,
+  MockControlCall,
+  TestBlock,
+  TestProfile,
+} from '../types/index.js';
+
+const ASSERTION_PATTERNS = new Set(['expect', 'assert', 'should']);
+const MOCK_PATTERNS = [
+  'jest.mock',
+  'vi.mock',
+  'sinon.stub',
+  'jest.spyOn',
+  'vi.spyOn',
+  'sinon.mock',
+];
+const RESTORE_PATTERNS = new Set([
+  'jest.restoreAllMocks',
+  'vi.restoreAllMocks',
+]);
+const SETUP_PATTERNS = new Set([
+  'beforeAll',
+  'beforeEach',
+  'afterAll',
+  'afterEach',
+]);
+const FOCUSED_PATTERNS = new Set([
+  'it.only',
+  'test.only',
+  'describe.only',
+  'it.skip',
+  'test.skip',
+  'describe.skip',
+  'it.todo',
+  'test.todo',
+]);
+const USE_FAKE_TIMER_PATTERNS = new Set([
+  'jest.useFakeTimers',
+  'vi.useFakeTimers',
+]);
+const USE_REAL_TIMER_PATTERNS = new Set([
+  'jest.useRealTimers',
+  'vi.useRealTimers',
+]);
+
+function getSpyOrStubKind(
+  call: ts.CallExpression,
+  sourceFile: ts.SourceFile
+): MockControlCall['kind'] | undefined {
+  if (!ts.isPropertyAccessExpression(call.expression)) return undefined;
+  const methodName = call.expression.name.getText(sourceFile);
+  const receiver = call.expression.expression.getText(sourceFile);
+
+  if ((receiver === 'jest' || receiver === 'vi') && methodName === 'spyOn')
+    return 'spy';
+  if (receiver === 'sinon' && (methodName === 'stub' || methodName === 'mock'))
+    return 'stub';
+  return undefined;
+}
+
+function getMockControlTarget(
+  node: ts.Node,
+  sourceFile: ts.SourceFile
+): string | undefined {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+
+    if (
+      ts.isVariableDeclaration(parent) &&
+      parent.initializer === current &&
+      ts.isIdentifier(parent.name)
+    ) {
+      return parent.name.getText(sourceFile);
+    }
+
+    if (
+      ts.isBinaryExpression(parent) &&
+      parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+      parent.right === current
+    ) {
+      return parent.left.getText(sourceFile).trim();
+    }
+
+    current = parent;
+  }
+
+  return undefined;
+}
+
+function getMockRestoreTarget(
+  node: ts.CallExpression,
+  sourceFile: ts.SourceFile
+): string | undefined {
+  if (!ts.isPropertyAccessExpression(node.expression)) return undefined;
+  return node.expression.expression.getText(sourceFile).trim();
+}
+
+export function collectTestProfile(
+  sourceFile: ts.SourceFile,
+  fileRelative: string,
+  fileEntry: FileEntry
+): void {
+  const testBlocks: TestBlock[] = [];
+  const mockCalls: CodeLocation[] = [];
+  const setupCalls: TestProfile['setupCalls'] = [];
+  const mutableStateDecls: CodeLocation[] = [];
+  const focusedCalls: TestProfile['focusedCalls'] = [];
+  const timerControls: TestProfile['timerControls'] = [];
+  const mockRestores: TestProfile['mockRestores'] = [];
+  const spyOrStubCalls: TestProfile['spyOrStubCalls'] = [];
+
+  const visit = (
+    node: ts.Node,
+    insideDescribe: boolean,
+    insideTest: boolean
+  ): void => {
+    if (ts.isCallExpression(node)) {
+      const callText = node.expression.getText(sourceFile);
+
+      if (FOCUSED_PATTERNS.has(callText)) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        focusedCalls.push({
+          kind: callText as TestProfile['focusedCalls'][0]['kind'],
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+
+      if (
+        (callText === 'it' ||
+          callText === 'test' ||
+          callText === 'it.only' ||
+          callText === 'test.only') &&
+        node.arguments.length >= 2
+      ) {
+        const nameArg = node.arguments[0];
+        const name = ts.isStringLiteral(nameArg) ? nameArg.text : callText;
+        const body = node.arguments[1];
+        const loc = getLineAndCharacter(sourceFile, node);
+        let assertionCount = 0;
+        const countAssertions = (n: ts.Node): void => {
+          if (ts.isCallExpression(n)) {
+            const t = n.expression.getText(sourceFile);
+            if (
+              ASSERTION_PATTERNS.has(t.split('.')[0]) ||
+              t.includes('.to.') ||
+              t.includes('.should')
+            )
+              assertionCount++;
+          }
+          ts.forEachChild(n, countAssertions);
+        };
+        ts.forEachChild(body, countAssertions);
+        testBlocks.push({
+          name,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+          assertionCount,
+        });
+        ts.forEachChild(node, child => visit(child, insideDescribe, true));
+        return;
+      }
+
+      if (
+        MOCK_PATTERNS.some(p => callText === p || callText.startsWith(p + '('))
+      ) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        mockCalls.push({
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+        const spyOrStubKind = getSpyOrStubKind(node, sourceFile);
+        if (spyOrStubKind) {
+          spyOrStubCalls.push({
+            kind: spyOrStubKind,
+            file: fileRelative,
+            lineStart: loc.lineStart,
+            lineEnd: loc.lineEnd,
+            target: getMockControlTarget(node, sourceFile),
+          });
+        }
+      }
+
+      if (USE_FAKE_TIMER_PATTERNS.has(callText)) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        timerControls.push({
+          kind: callText as TestProfile['timerControls'][0]['kind'],
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+
+      if (USE_REAL_TIMER_PATTERNS.has(callText)) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        timerControls.push({
+          kind: callText as TestProfile['timerControls'][0]['kind'],
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+
+      if (RESTORE_PATTERNS.has(callText)) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        mockRestores.push({
+          kind: 'restoreAll',
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      } else if (callText.endsWith('.mockRestore')) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        mockRestores.push({
+          kind: 'restore',
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+          target: getMockRestoreTarget(node, sourceFile),
+        });
+      }
+
+      if (SETUP_PATTERNS.has(callText)) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        setupCalls.push({
+          kind: callText as TestProfile['setupCalls'][0]['kind'],
+          lineStart: loc.lineStart,
+        });
+      }
+
+      if (callText === 'describe' || callText === 'describe.only') {
+        ts.forEachChild(node, child => visit(child, true, insideTest));
+        return;
+      }
+    }
+
+    if (insideDescribe && !insideTest && ts.isVariableStatement(node)) {
+      const decl = node.declarationList;
+      if (decl.flags & ts.NodeFlags.Let || !(decl.flags & ts.NodeFlags.Const)) {
+        const loc = getLineAndCharacter(sourceFile, node);
+        mutableStateDecls.push({
+          file: fileRelative,
+          lineStart: loc.lineStart,
+          lineEnd: loc.lineEnd,
+        });
+      }
+    }
+
+    ts.forEachChild(node, child => visit(child, insideDescribe, insideTest));
+  };
+
+  ts.forEachChild(sourceFile, child => visit(child, false, false));
+
+  fileEntry.testProfile = {
+    testBlocks,
+    mockCalls,
+    setupCalls,
+    mutableStateDecls,
+    focusedCalls,
+    timerControls,
+    mockRestores,
+    spyOrStubCalls,
+  };
+}

package/skills/octocode-code-engineer/src/common/is-direct-run.test.ts

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import { isDirectRun } from './is-direct-run.js';
+
+describe('isDirectRun', () => {
+  it('returns false when argv1 is missing', () => {
+    expect(isDirectRun(pathToFileURL('/tmp/example.js').href, undefined)).toBe(false);
+  });
+
+  it('matches the current module path for absolute argv1', () => {
+    const file = path.join(process.cwd(), 'scripts', 'example.js');
+
+    expect(isDirectRun(pathToFileURL(file).href, file)).toBe(true);
+  });
+
+  it('matches the current module path for relative argv1', () => {
+    const file = path.join(process.cwd(), 'scripts', 'example.js');
+    const relativeFile = path.relative(process.cwd(), file);
+
+    expect(isDirectRun(pathToFileURL(file).href, relativeFile)).toBe(true);
+  });
+
+  it('returns false for imported modules', () => {
+    const file = path.join(process.cwd(), 'scripts', 'example.js');
+    const differentFile = path.join(process.cwd(), 'scripts', 'other.js');
+
+    expect(isDirectRun(pathToFileURL(file).href, differentFile)).toBe(false);
+  });
+});