lonny-agent 0.2.3 → 0.2.6

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:
@@ -44,13 +49,12 @@ export function buildSystemPrompt(config: Config): string {
 - \`glob\`: Find files by glob pattern (pattern: 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)
+      - \`bash\`: Execute a shell command — for running commands (NOT for creating or modifying files — use \`edit\` for that)
+- \`edit\`: Replace text in files using markdown code block format. Use: \`edit({ content: "\`\`\`edit\\nfile: path\\nold: |\\ntext\\nnew: |\\ntext\\n\`\`\`" })\`
 - \`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)
 - \`search\`: Search the web using Tavily (query: string, search_depth?: string, include_answer?: boolean, max_results?: number, topic?: string, days?: number)
-- \`exec\`: Run JavaScript in a sandbox to orchestrate multiple tool calls — all tools are available as \`await tools.xxx(args)\` inside exec (code mode only)
 `
   }
 
@@ -59,8 +63,7 @@ export function buildSystemPrompt(config: Config): string {
 RULES:
 1. Read first: Use read/grep/glob tools to gather all context you need before making any edits.
 2. Be thorough: Explore the relevant parts of the codebase.
-3. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({edits: [...]})\` to edit multiple files at once. Do NOT do sequential single-file reads or single-edit calls.
-4. When using \`edit\`, the \`edits\` value MUST be an array — even for a single change. Do NOT pass empty objects.
+3. COST OPTIMIZATION (CRITICAL): Each API call costs money. You MUST maximize work per call. Use \`read(paths: [...])\` to read multiple files at once. Use \`edit({ content: "..." })\` with multiple \`\`\`edit blocks to edit multiple files at once.
 
 ${getToolListForMode(config.mode)}`
 
@@ -69,7 +72,7 @@ ${getToolListForMode(config.mode)}`
     config.mode === 'plan'
       ? `You are a planning agent. Your ONLY job is to investigate the codebase and produce an actionable implementation plan with a todo list.
 
-You CANNOT edit files. You do NOT have access to edit, bash (write mode), exec, or install_skill.
+You CANNOT edit files. You do NOT have access to edit, bash (write mode), or install_skill.
 Any attempt to call these tools will FAIL — they are simply unavailable in this mode.
 
 RULES (plan-specific):
@@ -78,7 +81,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):
@@ -110,9 +114,15 @@ RULES (ask-specific):
 
 RULES (code-specific):
 1. Read first: Use read/grep/glob tools to gather all context you need BEFORE making any edits. The \`read\` output prefixes each line with "<lineNumber>: " for easy reference. Do NOT include the "N: " prefix when copying text into \`edit\`.
-2. edit CALL FORMAT — you MUST call edit with exactly this JSON shape:
-   { "edits": [{ "file_path": "src/file.ts", "old_string": "text to replace", "new_string": "replacement text" }] }
-   The "edits" value is ALWAYS an array, even for a single edit. Do NOT pass file_path/old_string/new_string as top-level keys. Do NOT pass an empty object {}.
+2. edit CALL FORMAT — use markdown code block format:
+   \`\`\`edit
+   file: src/file.ts
+   old: |
+     text to replace
+   new: |
+     replacement text
+   \`\`\`
+   Use separate \`\`\`edit blocks for multiple files.
 3. After making edits to a file, if you need to make ANOTHER edit to the SAME file, you MUST re-read it first to get the updated content.
 4. If \`edit\` reports \`old_string not found\`, do NOT retry with the same old_string — re-read the file immediately to see its actual current content, then retry with correctly-copied text.
 5. When copying old_string from \`read\` output, include 2-3 lines of context BEFORE and AFTER the target change to make the string unique in the file.
@@ -171,5 +181,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}`
 }