sdk: Fix auto-generation of project files if none provided. Add unit tests for initial session state

Author: jahooma

bun.lock

@@ -0,0 +1,288 @@
+import { describe, expect, test, beforeEach } from 'bun:test'
+import { z } from 'zod/v4'
+import { initialSessionState } from '../run-state'
+import type { CodebuffFileSystem } from '@codebuff/common/types/filesystem'
+
+describe('Initial Session State', () => {
+  let mockFs: CodebuffFileSystem
+  let mockLogger: any
+
+  beforeEach(() => {
+    mockFs = {
+      readFile: async (path: string) => {
+        if (path.includes('src/index.ts')) {
+          return 'console.log("Hello world");'
+        }
+        if (path.includes('src/utils.ts')) {
+          return 'export function add(a: number, b: number) { return a + b; }'
+        }
+        if (path.includes('knowledge.md')) {
+          return '# Knowledge\n\nThis is a knowledge file.'
+        }
+        if (path.includes('README.md')) {
+          return '# Project\n\nThis is a readme.'
+        }
+        if (path.includes('.gitignore')) {
+          return 'node_modules/\n.git/'
+        }
+        throw new Error(`File not found: ${path}`)
+      },
+      readdir: async (path: string) => {
+        if (path.includes('test-project')) {
+          return [
+            { name: 'src', isDirectory: () => true, isFile: () => false },
+            { name: '.git', isDirectory: () => true, isFile: () => false },
+            { name: 'knowledge.md', isDirectory: () => false, isFile: () => true },
+            { name: 'README.md', isDirectory: () => false, isFile: () => true },
+            { name: '.gitignore', isDirectory: () => false, isFile: () => true },
+          ] as any
+        }
+        if (path.includes('src')) {
+          return [
+            { name: 'index.ts', isDirectory: () => false, isFile: () => true },
+            { name: 'utils.ts', isDirectory: () => false, isFile: () => true },
+          ] as any
+        }
+        return []
+      },
+      stat: async (path: string) => ({
+        isDirectory: () => path.includes('src') || path.includes('.git'),
+        isFile: () => !path.includes('src') && !path.includes('.git'),
+      }) as any,
+      exists: async (path: string) => {
+        if (path.includes('.gitignore')) return true
+        if (path.includes('src')) return true
+        if (path.includes('.git')) return true
+        if (path.includes('knowledge.md')) return true
+        if (path.includes('README.md')) return true
+        return false
+      },
+    } as any
+
+    mockLogger = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    }
+  })
+
+  test('creates initial session state with explicit projectFiles', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+      'src/utils.ts': 'export function add(a: number, b: number) { return a + b; }',
+      'knowledge.md': '# Knowledge\n\nThis is a knowledge file.',
+    }
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.fileTree).toBeDefined()
+    expect(sessionState.fileContext.fileTree.length).toBeGreaterThan(0)
+    expect(sessionState.fileContext.fileTokenScores).toBeDefined()
+    expect(sessionState.mainAgentState.agentId).toBe('main-agent')
+    expect(sessionState.mainAgentState.messageHistory).toEqual([])
+  })
+
+  test('discovers project files automatically when projectFiles is undefined', async () => {
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles: undefined,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.fileTree).toBeDefined()
+    expect(sessionState.mainAgentState.agentId).toBe('main-agent')
+    expect(sessionState.mainAgentState.messageHistory).toEqual([])
+  })
+
+  test('derives knowledgeFiles from projectFiles when not provided', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+      'knowledge.md': '# Knowledge\n\nThis is a knowledge file.',
+      'claude.md': '# Claude context\n\nThis is claude context.',
+      'README.md': '# Project\n\nThis is a readme.',
+    }
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      knowledgeFiles: undefined,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.knowledgeFiles).toBeDefined()
+    expect(sessionState.fileContext.knowledgeFiles['knowledge.md']).toBe(
+      '# Knowledge\n\nThis is a knowledge file.',
+    )
+    expect(sessionState.fileContext.knowledgeFiles['claude.md']).toBe(
+      '# Claude context\n\nThis is claude context.',
+    )
+    expect(sessionState.fileContext.knowledgeFiles['README.md']).toBeUndefined()
+  })
+
+  test('respects explicit knowledgeFiles when provided', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+      'knowledge.md': '# Knowledge\n\nThis is a knowledge file.',
+    }
+
+    const knowledgeFiles = {
+      'custom-knowledge.md': '# Custom Knowledge\n\nThis is custom knowledge.',
+    }
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      knowledgeFiles,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.knowledgeFiles).toEqual(knowledgeFiles)
+    expect(sessionState.fileContext.knowledgeFiles['knowledge.md']).toBeUndefined()
+  })
+
+  test('sets maxAgentSteps when provided', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+    }
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      maxAgentSteps: 10,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.mainAgentState.stepsRemaining).toBe(10)
+  })
+
+  test('includes custom agent definitions', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+    }
+
+    const agentDefinitions = [
+      {
+        id: 'custom-agent',
+        displayName: 'Custom Agent',
+        spawnerPrompt: 'A custom agent',
+        model: 'anthropic/claude-4-sonnet-20250522',
+        outputMode: 'last_message' as const,
+        includeMessageHistory: false,
+        inheritParentSystemPrompt: false,
+        mcpServers: {},
+        toolNames: [],
+        spawnableAgents: [],
+        inputSchema: {},
+        systemPrompt: 'Custom system prompt',
+        instructionsPrompt: '',
+        stepPrompt: '',
+      },
+    ]
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      agentDefinitions,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.agentTemplates).toBeDefined()
+    expect(sessionState.fileContext.agentTemplates['custom-agent']).toBeDefined()
+    expect(sessionState.fileContext.agentTemplates['custom-agent'].displayName).toBe(
+      'Custom Agent',
+    )
+  })
+
+  test('includes custom tool definitions', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+    }
+
+    const inputSchema = z.object({ input: z.string() })
+    const customToolDefinitions = [
+      {
+        toolName: 'custom_tool',
+        zodSchema: inputSchema,
+        inputJsonSchema: {
+          type: 'object' as const,
+          properties: {
+            input: { type: 'string' as const },
+          },
+        },
+        description: 'A custom tool',
+        endsAgentStep: false,
+        exampleInputs: [],
+        execute: async (input: any) => [],
+      },
+    ]
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      customToolDefinitions,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.customToolDefinitions).toBeDefined()
+    expect(sessionState.fileContext.customToolDefinitions['custom_tool']).toBeDefined()
+    expect(sessionState.fileContext.customToolDefinitions['custom_tool'].description).toBe(
+      'A custom tool',
+    )
+  })
+
+  test('populates system info correctly', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+    }
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.fileContext.systemInfo).toBeDefined()
+    expect(sessionState.fileContext.systemInfo.platform).toBe(process.platform)
+    expect(sessionState.fileContext.systemInfo.shell).toBeDefined()
+    expect(sessionState.fileContext.systemInfo.nodeVersion).toBe(process.version)
+    expect(sessionState.fileContext.systemInfo.cpus).toBeGreaterThan(0)
+  })
+
+  test('initializes empty agent state correctly', async () => {
+    const projectFiles = {
+      'src/index.ts': 'console.log("Hello world");',
+    }
+
+    const sessionState = await initialSessionState({
+      cwd: '/test-project',
+      projectFiles,
+      fs: mockFs,
+      logger: mockLogger,
+    })
+
+    expect(sessionState.mainAgentState.agentId).toBe('main-agent')
+    expect(sessionState.mainAgentState.agentType).toBeNull()
+    expect(sessionState.mainAgentState.agentContext).toEqual({})
+    expect(sessionState.mainAgentState.ancestorRunIds).toEqual([])
+    expect(sessionState.mainAgentState.subagents).toEqual([])
+    expect(sessionState.mainAgentState.childRunIds).toEqual([])
+    expect(sessionState.mainAgentState.messageHistory).toEqual([])
+    expect(sessionState.mainAgentState.creditsUsed).toBe(0)
+    expect(sessionState.mainAgentState.directCreditsUsed).toBe(0)
+    expect(sessionState.mainAgentState.output).toBeUndefined()
+    expect(sessionState.mainAgentState.parentId).toBeUndefined()
+  })
+})

sdk/src/__tests__/initial-session-state.test.ts

@@ -196,12 +196,6 @@ export async function initialSessionState(
   if (!customToolDefinitions) {
     customToolDefinitions = []
   }
-  if (!projectFiles) {
-    projectFiles = {}
-  }
-  if (!knowledgeFiles) {
-    knowledgeFiles = {}
-  }
   if (!fs) {
     fs = (require('fs') as typeof fsType).promises
   }
@@ -218,11 +212,9 @@ export async function initialSessionState(
   if (projectFiles === undefined && cwd) {
     projectFiles = await discoverProjectFiles({ cwd, fs, logger })
   }
-  logger.info({ projectFiles }, 'asdf')
   if (knowledgeFiles === undefined) {
     knowledgeFiles = projectFiles ? deriveKnowledgeFiles(projectFiles) : {}
   }
-  logger.info({ knowledgeFiles }, 'asdf')
 
   const processedAgentTemplates = processAgentDefinitions(agentDefinitions)
   const processedCustomToolDefinitions = processCustomToolDefinitions(

sdk/src/run-state.ts

@@ -349,6 +349,7 @@ export async function run({
       projectFiles,
       maxAgentSteps,
       fs,
+      logger,
     })
   }