lonny-agent 0.2.3 → 0.2.4

package/src/agent/project.ts

@@ -0,0 +1,366 @@
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+
+// ── Project type detection ─────────────────────────────────────────────────
+
+export type ProjectType = 'node' | 'python' | 'rust' | 'go' | 'java' | 'cpp' | 'unknown'
+
+export interface ProjectInfo {
+  type: ProjectType
+  entryPoints: string[]
+  dependencies: Record<string, string>
+  devDependencies: Record<string, string>
+  testFiles: string[]
+  configFiles: string[]
+  srcDirs: string[]
+  hasTests: boolean
+  packageManager: 'npm' | 'yarn' | 'pnpm' | 'bun' | null
+}
+
+interface PackageJson {
+  name?: string
+  version?: string
+  main?: string
+  module?: string
+  exports?: string | Record<string, string>
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  scripts?: Record<string, string>
+  type?: string
+}
+
+// Common entry point patterns
+const ENTRY_PATTERNS: Record<ProjectType, string[]> = {
+  node: [
+    'src/index.ts',
+    'src/main.ts',
+    'src/app.ts',
+    'src/server.ts',
+    'index.ts',
+    'app.ts',
+    'server.ts',
+    'main.ts',
+  ],
+  python: ['main.py', 'app.py', 'src/main.py', 'src/app.py'],
+  rust: ['src/main.rs', 'src/lib.rs'],
+  go: ['main.go', 'cmd/main.go'],
+  java: ['src/main/java/Main.java'],
+  cpp: ['src/main.cpp', 'main.cpp'],
+  unknown: [],
+}
+
+const TEST_PATTERNS: Record<ProjectType, string[]> = {
+  node: ['**/*.test.ts', '**/*.spec.ts', '**/__tests__/**', 'tests/**/*.ts'],
+  python: ['test_*.py', '*_test.py', 'tests/**/*.py'],
+  rust: ['tests/**/*.rs', 'src/**/*.rs'],
+  go: ['*_test.go'],
+  java: ['**/*Test.java', '**/*Tests.java'],
+  cpp: ['**/*test*.cpp', 'tests/**/*.cpp'],
+  unknown: [],
+}
+
+const CONFIG_FILES: Record<ProjectType, string[]> = {
+  node: [
+    'package.json',
+    'tsconfig.json',
+    'biome.json',
+    '.biomerc',
+    'jest.config.*',
+    'vitest.config.*',
+    '.eslintrc*',
+    '.prettierrc*',
+    '.npmrc',
+  ],
+  python: [
+    'pyproject.toml',
+    'setup.py',
+    'setup.cfg',
+    'requirements.txt',
+    'Pipfile',
+    'poetry.lock',
+    'pytest.ini',
+    'pyproject.toml',
+  ],
+  rust: ['Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml'],
+  go: ['go.mod', 'go.sum'],
+  java: ['pom.xml', 'build.gradle', 'build.gradle.kts'],
+  cpp: ['CMakeLists.txt', 'Makefile', '*.cmake'],
+  unknown: [],
+}
+
+const SRC_DIRS: Record<ProjectType, string[]> = {
+  node: ['src', 'lib', 'app', 'packages'],
+  python: ['src', 'lib', 'app'],
+  rust: ['src'],
+  go: ['cmd', 'internal', 'pkg'],
+  java: ['src/main/java', 'src'],
+  cpp: ['src', 'lib', 'include'],
+  unknown: [],
+}
+
+// ── Detection functions ───────────────────────────────────────────────────
+
+/** Detect project type from root directory */
+async function detectProjectType(cwd: string): Promise<ProjectType> {
+  const files = await fs.readdir(cwd, { withFileTypes: true })
+  const fileNames = files.map(f => f.name.toLowerCase())
+
+  // Priority order matters
+  if (fileNames.includes('cargo.toml')) return 'rust'
+  if (fileNames.includes('go.mod')) return 'go'
+  if (fileNames.includes('pom.xml') || fileNames.includes('build.gradle')) return 'java'
+  if (fileNames.includes('package.json')) return 'node'
+  if (
+    fileNames.includes('pyproject.toml') ||
+    fileNames.includes('setup.py') ||
+    fileNames.includes('requirements.txt')
+  )
+    return 'python'
+  if (fileNames.includes('cmakelists.txt')) return 'cpp'
+
+  return 'unknown'
+}
+
+/** Find entry points for the project */
+async function findEntryPoints(cwd: string, type: ProjectType): Promise<string[]> {
+  if (type === 'unknown') return []
+
+  const entryPoints: string[] = []
+  const patterns = ENTRY_PATTERNS[type]
+
+  for (const pattern of patterns) {
+    const fullPath = path.join(cwd, pattern)
+    try {
+      const stat = await fs.stat(fullPath)
+      if (stat.isFile()) {
+        entryPoints.push(pattern)
+      }
+    } catch {
+      // File doesn't exist, skip
+    }
+  }
+
+  // For Node.js, also check package.json main/module
+  if (type === 'node') {
+    try {
+      const pkgPath = path.join(cwd, 'package.json')
+      const content = await fs.readFile(pkgPath, 'utf-8')
+      const pkg: PackageJson = JSON.parse(content)
+      if (pkg.main && !entryPoints.includes(pkg.main)) {
+        entryPoints.push(pkg.main)
+      }
+      if (pkg.module && !entryPoints.includes(pkg.module)) {
+        entryPoints.push(pkg.module)
+      }
+    } catch {
+      // No package.json
+    }
+  }
+
+  return entryPoints
+}
+
+/** Find test files */
+async function findTestFiles(cwd: string, type: ProjectType): Promise<string[]> {
+  if (type === 'unknown') return []
+
+  const testFiles: string[] = []
+  const patterns = TEST_PATTERNS[type]
+
+  // Simple glob simulation - just check common locations
+  const dirs =
+    type === 'node'
+      ? ['src', 'tests', '__tests__', '']
+      : type === 'python'
+        ? ['tests', '']
+        : type === 'rust'
+          ? ['tests', 'src']
+          : ['']
+
+  for (const dir of dirs) {
+    const searchDir = dir ? path.join(cwd, dir) : cwd
+    try {
+      const files = await fs.readdir(searchDir, { withFileTypes: true })
+      for (const file of files) {
+        if (file.isFile()) {
+          const name = file.name.toLowerCase()
+          if (name.includes('test') || name.includes('spec')) {
+            const relPath = dir ? `${dir}/${file.name}` : file.name
+            testFiles.push(relPath)
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist
+    }
+  }
+
+  return testFiles.slice(0, 10) // Limit to 10
+}
+
+/** Find config files */
+async function findConfigFiles(cwd: string, type: ProjectType): Promise<string[]> {
+  const configs: string[] = []
+  const patterns = CONFIG_FILES[type] || []
+
+  for (const pattern of patterns) {
+    const fullPath = path.join(cwd, pattern)
+    try {
+      const stat = await fs.stat(fullPath)
+      if (stat.isFile()) {
+        configs.push(pattern)
+      }
+    } catch {
+      // File doesn't exist
+    }
+  }
+
+  return configs
+}
+
+/** Find source directories */
+async function findSrcDirs(cwd: string, type: ProjectType): Promise<string[]> {
+  const srcDirs: string[] = []
+  const patterns = SRC_DIRS[type] || []
+
+  for (const pattern of patterns) {
+    const fullPath = path.join(cwd, pattern)
+    try {
+      const stat = await fs.stat(fullPath)
+      if (stat.isDirectory()) {
+        srcDirs.push(pattern)
+      }
+    } catch {
+      // Directory doesn't exist
+    }
+  }
+
+  return srcDirs
+}
+
+/** Detect package manager */
+async function detectPackageManager(cwd: string): Promise<ProjectInfo['packageManager']> {
+  const files = await fs.readdir(cwd, { withFileTypes: true })
+  const fileNames = files.map(f => f.name)
+
+  if (fileNames.includes('pnpm-lock.yaml')) return 'pnpm'
+  if (fileNames.includes('yarn.lock')) return 'yarn'
+  if (fileNames.includes('bun.lockb')) return 'bun'
+  if (fileNames.includes('package-lock.json')) return 'npm'
+
+  return null
+}
+
+/** Load dependencies from package.json */
+async function loadDependencies(
+  cwd: string,
+): Promise<{ deps: Record<string, string>; devDeps: Record<string, string> }> {
+  try {
+    const pkgPath = path.join(cwd, 'package.json')
+    const content = await fs.readFile(pkgPath, 'utf-8')
+    const pkg: PackageJson = JSON.parse(content)
+    return {
+      deps: pkg.dependencies || {},
+      devDeps: pkg.devDependencies || {},
+    }
+  } catch {
+    return { deps: {}, devDeps: {} }
+  }
+}
+
+// ── Main discovery function ───────────────────────────────────────────────
+
+// Cache for project info
+const projectCache = new Map<string, { info: ProjectInfo; timestamp: number }>()
+const CACHE_TTL = 60_000 // 1 minute
+
+/**
+ * Discover project information for a given directory.
+ * Results are cached for 1 minute to avoid repeated disk I/O.
+ */
+export async function discoverProject(cwd: string): Promise<ProjectInfo> {
+  // Check cache first
+  const cached = projectCache.get(cwd)
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.info
+  }
+
+  const type = await detectProjectType(cwd)
+  const [entryPoints, testFiles, configFiles, srcDirs, packageManager, deps] = await Promise.all([
+    findEntryPoints(cwd, type),
+    findTestFiles(cwd, type),
+    findConfigFiles(cwd, type),
+    findSrcDirs(cwd, type),
+    detectPackageManager(cwd),
+    type === 'node' ? loadDependencies(cwd) : Promise.resolve({ deps: {}, devDeps: {} }),
+  ])
+
+  const info: ProjectInfo = {
+    type,
+    entryPoints,
+    dependencies: deps.deps,
+    devDependencies: deps.devDeps,
+    testFiles,
+    configFiles,
+    srcDirs,
+    hasTests: testFiles.length > 0,
+    packageManager,
+  }
+
+  // Cache the result
+  projectCache.set(cwd, { info, timestamp: Date.now() })
+
+  return info
+}
+
+/** Clear project cache */
+export function clearProjectCache(): void {
+  projectCache.clear()
+}
+
+/** Invalidate cache for a specific directory */
+export function invalidateProjectCache(cwd: string): void {
+  projectCache.delete(cwd)
+}
+
+/**
+ * Format project info as a string for inclusion in prompts.
+ */
+export function formatProjectContext(info: ProjectInfo): string {
+  const lines: string[] = ['## Project Context']
+
+  if (info.type === 'unknown') {
+    lines.push('- Project type: Unknown')
+    return lines.join('\n')
+  }
+
+  lines.push(`- Project type: ${info.type}`)
+  lines.push(`- Package manager: ${info.packageManager || 'unknown'}`)
+
+  if (info.entryPoints.length > 0) {
+    lines.push(`- Entry point(s): ${info.entryPoints.join(', ')}`)
+  }
+
+  if (info.srcDirs.length > 0) {
+    lines.push(`- Source directories: ${info.srcDirs.join(', ')}`)
+  }
+
+  if (info.configFiles.length > 0) {
+    lines.push(`- Config files: ${info.configFiles.join(', ')}`)
+  }
+
+  if (info.hasTests) {
+    const testCount = info.testFiles.length
+    lines.push(`- Test files: ${testCount} found`)
+  }
+
+  // Show main dependencies
+  const mainDeps = Object.keys(info.dependencies).slice(0, 10)
+  if (mainDeps.length > 0) {
+    lines.push(
+      `- Dependencies: ${mainDeps.join(', ')}${Object.keys(info.dependencies).length > 10 ? '...' : ''}`,
+    )
+  }
+
+  return lines.join('\n')
+}

package/src/agent/prompt-builder.ts

@@ -1,12 +1,13 @@
 import * as os from 'node:os'
 import type { Config } from '../config/index.js'
+import { discoverProject, formatProjectContext } from './project.js'
 import { formatSkillsForPrompt, loadSkills } from './skills.js'
 
 /**
  * Build the system prompt for the current configuration.
  * Extracted from session.ts to keep module size manageable (<500 LoC target).
  */
-export function buildSystemPrompt(config: Config): string {
+export async function buildSystemPrompt(config: Config): Promise<string> {
   const platform = os.platform()
   const release = os.release()
   const shell = process.env.SHELL || process.env.ComSpec || 'unknown'
@@ -18,6 +19,10 @@ export function buildSystemPrompt(config: Config): string {
   const skills = loadSkills(cwd)
   const skillsSection = formatSkillsForPrompt(skills)
 
+  // ── Load project context ─────────────────────────────────────────────────
+  const projectInfo = await discoverProject(cwd)
+  const projectSection = formatProjectContext(projectInfo)
+
   // ── Mode-specific tool list ───────────────────────────────────────────
   function getToolListForMode(mode: string): string {
     if (mode === 'ask') {
@@ -36,7 +41,7 @@ export function buildSystemPrompt(config: Config): string {
 - \`find\`: Find files by name pattern (pattern: string, path?: string, maxResults?: number)
 - \`git\`: Run read-only git commands (command: string)
 - \`search\`: Search the web using Tavily (query: string, search_depth?: string, include_answer?: boolean, max_results?: number, topic?: string, days?: number)
-- \`write_plan\`: Save plan/todo markdown into .lonny/ folder
+- \`write_plan\`: Save plan/todo markdown into .lonny/ folder (use descriptive names like backend-api.md, frontend-ui.md if splitting into multiple files)
 `
     }
     return `Available tools:
@@ -45,7 +50,7 @@ export function buildSystemPrompt(config: Config): string {
 - \`grep\`: Search file content by regex (pattern: string, include?: string, path?: string)
 - \`ls\`: List directory (path?: string)
 - \`bash\`: Execute a shell command
-- \`edit\`: Replace text in files — call with {"edits": [{"file_path", "old_string", "new_string"}]} (array required)
+- \`edit\`: Replace text in files — call with {edits: [{file_path: string, old_string: string, new_string: string}]} (array required)
 - \`install_skill\`: Install an npm package as a skill — fetches package info from npm, runs npm install, and creates a .lonny/skills/ file with usage instructions for the AI
 - \`find\`: Find files by name pattern (pattern: string, path?: string, maxResults?: number)
 - \`git\`: Run read-only git commands (command: string)
@@ -78,7 +83,8 @@ RULES (plan-specific):
 3. Use \`bash\` for investigation only — NEVER to modify files, install packages, or run write operations.
 4. Your ONLY output is a plan file saved via \`write_plan\`. You CANNOT modify the codebase directly.
 5. You MUST persist the final plan AND todo list to a file in \`.lonny/\` using \`write_plan\`. The \`write_plan\` content MUST include both ## Plan and ## Todo List sections.
-6. You MUST also include the todo list in your text response to the user (not just in the file).
+6. If the plan is very long (or the todo list has many items), split into multiple files with descriptive names like \`backend-api.md\`, \`frontend-ui.md\`, \`database.md\`, etc.
+7. You MUST also include the todo list in your text response to the user (not just in the file).
 7. If the user asks you to modify files, run write commands, or install packages — refuse and explain they need to switch to code mode (\`/mode code\`).
 
 OUTPUT FORMAT (you MUST include both in write_plan AND in your response text):
@@ -171,5 +177,5 @@ ${isWindows ? '  - Use `type` instead of `cat`, `dir` instead of `ls`, `where` i
 ${sharedRules}`
   return `${modeInstructions}
 
-${envSection}${rulesSection}${methodologySection}${skillsSection}`
+${envSection}${rulesSection}${methodologySection}${projectSection}${skillsSection}`
 }

package/src/agent/providers/anthropic.ts

@@ -117,9 +117,14 @@ export class AnthropicProvider implements LLMProvider {
       } else if (event.type === 'content_block_stop') {
         if (currentToolUse) {
           let input: Record<string, unknown>
+          const rawInput = currentToolUse.input || ''
           try {
-            input = JSON.parse(currentToolUse.input || '{}')
+            input = JSON.parse(rawInput || '{}')
           } catch {
+            console.error(
+              '[anthropic] Failed to parse tool_use input (content_block_stop):',
+              rawInput,
+            )
             input = {}
           }
           yield {
@@ -145,9 +150,11 @@ export class AnthropicProvider implements LLMProvider {
         if (event.delta.stop_reason === 'end_turn' || event.delta.stop_reason === 'stop_sequence') {
           if (currentToolUse) {
             let input: Record<string, unknown>
+            const rawInput = currentToolUse.input || ''
             try {
-              input = JSON.parse(currentToolUse.input || '{}')
+              input = JSON.parse(rawInput || '{}')
             } catch {
+              console.error('[anthropic] Failed to parse tool_use input (message_delta):', rawInput)
               input = {}
             }
             yield {

package/src/agent/providers/google.ts

@@ -203,7 +203,7 @@ export class GoogleProvider implements LLMProvider {
             }
           }
         } catch {
-          // skip malformed JSON
+          console.error('[google] Failed to parse stream chunk:', jsonStr)
         }
       }
     }

package/src/agent/providers/ollama.ts

@@ -150,6 +150,10 @@ export class OllamaProvider implements LLMProvider {
               try {
                 input = JSON.parse(tc.function.arguments || '{}')
               } catch {
+                console.error(
+                  '[ollama] Failed to parse tool_call arguments:',
+                  tc.function.arguments,
+                )
                 input = {}
               }
               yield {
@@ -174,7 +178,7 @@ export class OllamaProvider implements LLMProvider {
             }
           }
         } catch {
-          // skip malformed JSON
+          console.error('[ollama] Failed to parse stream line:', line)
         }
       }
     }

package/src/agent/providers/openai.ts

@@ -201,9 +201,14 @@ export class OpenAIProvider implements LLMProvider {
           if (tc.id) {
             if (currentToolCall) {
               let input: Record<string, unknown>
+              const rawArgs = currentToolCall.arguments || ''
               try {
-                input = JSON.parse(currentToolCall.arguments || '{}')
+                input = JSON.parse(rawArgs || '{}')
               } catch {
+                console.error(
+                  '[openai] Failed to parse tool_call arguments (flush on new tool):',
+                  rawArgs,
+                )
                 input = {}
               }
               yield {
@@ -230,17 +235,22 @@ export class OpenAIProvider implements LLMProvider {
 
       if (chunk.choices?.[0]?.finish_reason) {
         if (currentToolCall) {
+          const finalArgs = currentToolCall.arguments || ''
           try {
             yield {
               type: 'tool_use',
               tool_call: {
                 id: currentToolCall.id,
                 name: currentToolCall.name,
-                input: JSON.parse(currentToolCall.arguments || '{}'),
+                input: JSON.parse(finalArgs || '{}'),
               },
               reasoning_content: reasoningContent,
             }
           } catch {
+            console.error(
+              '[openai] Failed to parse tool_call arguments (finish_reason):',
+              finalArgs,
+            )
             yield {
               type: 'tool_use',
               tool_call: {
@@ -303,9 +313,11 @@ export class OpenAIProvider implements LLMProvider {
           }
         : undefined
       let input: Record<string, unknown>
+      const rawFinalArgs = currentToolCall.arguments || ''
       try {
-        input = JSON.parse(currentToolCall.arguments || '{}')
+        input = JSON.parse(rawFinalArgs || '{}')
       } catch {
+        console.error('[openai] Failed to parse tool_call arguments (final flush):', rawFinalArgs)
         input = {}
       }
       yield {