@oculum/scanner 1.0.11 → 1.0.12

package/src/ai-context/__tests__/manager.test.ts

@@ -0,0 +1,193 @@
+/**
+ * AIContextManager Tests
+ */
+
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+import { AIContextManager } from '../manager'
+
+describe('AIContextManager', () => {
+  const testDir = join(tmpdir(), 'oculum-ai-context-test-' + Date.now())
+
+  beforeAll(() => {
+    // Create test directory
+    mkdirSync(testDir, { recursive: true })
+  })
+
+  afterAll(() => {
+    // Clean up test directory
+    try {
+      rmSync(testDir, { recursive: true, force: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  })
+
+  beforeEach(() => {
+    // Clean up .oculum directory before each test
+    const oculumDir = join(testDir, '.oculum')
+    try {
+      rmSync(oculumDir, { recursive: true, force: true })
+    } catch {
+      // Ignore errors
+    }
+  })
+
+  describe('saveContext', () => {
+    it('should create .oculum directory if not exists', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+      const content = '# AI Context\n\nTest content'
+
+      const result = manager.saveContext(content)
+
+      expect(result.success).toBe(true)
+      expect(existsSync(join(testDir, '.oculum'))).toBe(true)
+      expect(existsSync(join(testDir, '.oculum', 'ai-context.md'))).toBe(true)
+    })
+
+    it('should save ai-context.md and return { success, path }', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+      const content = '# Security Issues\n\n1. SQL Injection in users.ts:42'
+
+      const result = manager.saveContext(content)
+
+      expect(result.success).toBe(true)
+      expect(result.path).toBe(join(testDir, '.oculum', 'ai-context.md'))
+
+      const savedContent = readFileSync(result.path, 'utf-8')
+      expect(savedContent).toBe(content)
+    })
+
+    it('should overwrite existing ai-context.md', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      // Save initial content
+      manager.saveContext('Initial content')
+
+      // Save new content
+      const newContent = 'Updated content'
+      const result = manager.saveContext(newContent)
+
+      expect(result.success).toBe(true)
+      const savedContent = readFileSync(result.path, 'utf-8')
+      expect(savedContent).toBe(newContent)
+    })
+
+    it('should return { success: false, error } on permission error', () => {
+      // Use an invalid path that will cause an error
+      const manager = new AIContextManager({ projectPath: '/nonexistent/path/that/does/not/exist' })
+
+      const result = manager.saveContext('test content')
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+      expect(result.error).toContain('Failed to save')
+    })
+  })
+
+  describe('loadContext', () => {
+    it('should load existing context file', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+      const content = '# AI Context\n\nSome security findings'
+
+      // Save first
+      manager.saveContext(content)
+
+      // Load
+      const result = manager.loadContext()
+
+      expect(result.found).toBe(true)
+      expect(result.content).toBe(content)
+    })
+
+    it('should return { found: false } when file does not exist', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      const result = manager.loadContext()
+
+      expect(result.found).toBe(false)
+      expect(result.content).toBeUndefined()
+    })
+
+    it('should return error if file cannot be read', () => {
+      // Create a directory with the same name as the file (to cause read error)
+      const oculumDir = join(testDir, '.oculum')
+      const contextPath = join(oculumDir, 'ai-context.md')
+
+      mkdirSync(oculumDir, { recursive: true })
+      mkdirSync(contextPath, { recursive: true }) // Create as directory
+
+      const manager = new AIContextManager({ projectPath: testDir })
+      const result = manager.loadContext()
+
+      expect(result.found).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+  })
+
+  describe('clearContext', () => {
+    it('should clear context file and return { success: true, existed: true }', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      // Save first
+      manager.saveContext('Some content')
+      expect(manager.hasContext()).toBe(true)
+
+      // Clear
+      const result = manager.clearContext()
+
+      expect(result.success).toBe(true)
+      expect(result.existed).toBe(true)
+      expect(manager.hasContext()).toBe(false)
+    })
+
+    it('should return { success: true, existed: false } when no context exists', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      const result = manager.clearContext()
+
+      expect(result.success).toBe(true)
+      expect(result.existed).toBe(false)
+    })
+  })
+
+  describe('hasContext', () => {
+    it('should return true when ai-context.md exists', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+      manager.saveContext('test')
+
+      expect(manager.hasContext()).toBe(true)
+    })
+
+    it('should return false when ai-context.md does not exist', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      expect(manager.hasContext()).toBe(false)
+    })
+  })
+
+  describe('getContextPath', () => {
+    it('should return the full path to ai-context.md', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      const path = manager.getContextPath()
+
+      expect(path).toBe(join(testDir, '.oculum', 'ai-context.md'))
+    })
+  })
+
+  describe('constructor', () => {
+    it('should support string argument for backward compatibility', () => {
+      const manager = new AIContextManager(testDir)
+
+      expect(manager.getContextPath()).toBe(join(testDir, '.oculum', 'ai-context.md'))
+    })
+
+    it('should support options object', () => {
+      const manager = new AIContextManager({ projectPath: testDir })
+
+      expect(manager.getContextPath()).toBe(join(testDir, '.oculum', 'ai-context.md'))
+    })
+  })
+})

package/src/ai-context/index.ts

@@ -0,0 +1,15 @@
+/**
+ * AI Context Module
+ * Exports for AI context management functionality
+ */
+
+export {
+  AIContextManager,
+  AI_CONTEXT_FILE,
+  AI_CONTEXT_PATH,
+  OCULUM_DIR,
+  type AIContextManagerOptions,
+  type SaveContextResult,
+  type LoadContextResult,
+  type ClearContextResult,
+} from './manager'

package/src/ai-context/manager.ts

@@ -0,0 +1,145 @@
+/**
+ * AI Context Manager
+ * Handles loading, saving, and clearing AI context files
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs'
+import { join } from 'path'
+
+/** AI context file name */
+export const AI_CONTEXT_FILE = 'ai-context.md'
+
+/** Directory for oculum files */
+export const OCULUM_DIR = '.oculum'
+
+/** Full path to AI context file (relative to project root) */
+export const AI_CONTEXT_PATH = `${OCULUM_DIR}/${AI_CONTEXT_FILE}`
+
+export interface AIContextManagerOptions {
+  /** Project root path */
+  projectPath: string
+}
+
+export interface SaveContextResult {
+  /** Whether the save was successful */
+  success: boolean
+  /** Path where context was saved */
+  path: string
+  /** Error message (if failed) */
+  error?: string
+}
+
+export interface LoadContextResult {
+  /** Whether a context file was found */
+  found: boolean
+  /** The context content (if found) */
+  content?: string
+  /** Error message (if failed to load) */
+  error?: string
+}
+
+export interface ClearContextResult {
+  /** Whether the clear was successful */
+  success: boolean
+  /** Whether a context file existed before clearing */
+  existed: boolean
+  /** Error message (if failed) */
+  error?: string
+}
+
+/**
+ * Manages AI context files for IDE consumption
+ */
+export class AIContextManager {
+  private projectPath: string
+  private contextPath: string
+
+  constructor(options: AIContextManagerOptions | string) {
+    // Support both old string arg and new options object
+    if (typeof options === 'string') {
+      this.projectPath = options
+    } else {
+      this.projectPath = options.projectPath
+    }
+    this.contextPath = join(this.projectPath, OCULUM_DIR, AI_CONTEXT_FILE)
+  }
+
+  /**
+   * Get the full path to the AI context file
+   */
+  getContextPath(): string {
+    return this.contextPath
+  }
+
+  /**
+   * Save AI context to .oculum/ai-context.md
+   */
+  saveContext(content: string): SaveContextResult {
+    try {
+      // Ensure .oculum directory exists
+      const oculumDir = join(this.projectPath, OCULUM_DIR)
+      if (!existsSync(oculumDir)) {
+        mkdirSync(oculumDir, { recursive: true })
+      }
+
+      // Write content to file
+      writeFileSync(this.contextPath, content)
+
+      return { success: true, path: this.contextPath }
+    } catch (err) {
+      return {
+        success: false,
+        path: this.contextPath,
+        error: `Failed to save AI context: ${err instanceof Error ? err.message : 'Unknown error'}`,
+      }
+    }
+  }
+
+  /**
+   * Load AI context from .oculum/ai-context.md
+   */
+  loadContext(): LoadContextResult {
+    if (!existsSync(this.contextPath)) {
+      return { found: false }
+    }
+
+    try {
+      const content = readFileSync(this.contextPath, 'utf-8')
+      return { found: true, content }
+    } catch (err) {
+      return {
+        found: false,
+        error: `Failed to read AI context: ${err instanceof Error ? err.message : 'Unknown error'}`,
+      }
+    }
+  }
+
+  /**
+   * Clear (delete) the AI context file
+   */
+  clearContext(): ClearContextResult {
+    const existed = existsSync(this.contextPath)
+
+    if (!existed) {
+      return { success: true, existed: false }
+    }
+
+    try {
+      unlinkSync(this.contextPath)
+      return { success: true, existed: true }
+    } catch (err) {
+      return {
+        success: false,
+        existed: true,
+        error: `Failed to clear AI context: ${err instanceof Error ? err.message : 'Unknown error'}`,
+      }
+    }
+  }
+
+  /**
+   * Check if an AI context file exists
+   */
+  hasContext(): boolean {
+    return existsSync(this.contextPath)
+  }
+}

package/src/baseline/__tests__/manager.test.ts

@@ -142,7 +142,7 @@ describe('BaselineManager', () => {
         timestamp: '2024-01-15T10:00:00.000Z',
       }
 
-      const result = manager.saveBaseline(scanResult, { scanDepth: 'cheap' })
+      const result = manager.saveBaseline(scanResult, { scanDepth: 'local' })
 
       expect(result.success).toBe(true)
       expect(existsSync(result.path)).toBe(true)
@@ -155,7 +155,7 @@ describe('BaselineManager', () => {
       expect(baseline.findings).toHaveLength(1)
       expect(baseline.findings[0].title).toBe('Hardcoded API key')
       expect(baseline.stats.critical).toBe(1)
-      expect(baseline.scanDepth).toBe('cheap')
+      expect(baseline.scanDepth).toBe('local')
     })
 
     it('should create .oculum directory if it does not exist', () => {