deeprise

Imported from MehdiGhorb/deeprise (AGENTS.md). Install upstream with npx skills add MehdiGhorb/deeprise. Copyright stays with the author.

• To regenerate the JavaScript SDK, run ./packages/sdk/js/script/build.ts.
• ALWAYS USE PARALLEL TOOLS WHEN APPLICABLE.
• The default branch in this repo is dev.
• Local main ref may not exist; use dev or origin/dev for diffs.
• Prefer automation: execute requested actions without confirmation unless blocked by missing info or safety/irreversibility.

Style Guide

General Principles

• Keep things in one function unless composable or reusable
• Avoid try/catch where possible
• Avoid using the any type
• Use Bun APIs when possible, like Bun.file()
• Rely on type inference when possible; avoid explicit type annotations or interfaces unless necessary for exports or clarity
• Prefer functional array methods (flatMap, filter, map) over for loops; use type guards on filter to maintain type inference downstream
• In src/config, follow the existing self-export pattern at the top of the file (for example export * as ConfigAgent from "./agent") when adding a new config module.

Reduce total variable count by inlining when a value is only used once.

// Good
const journal = await Bun.file(path.join(dir, "journal.json")).json()

// Bad
const journalPath = path.join(dir, "journal.json")
const journal = await Bun.file(journalPath).json()

Destructuring

Avoid unnecessary destructuring. Use dot notation to preserve context.

// Good
obj.a
obj.b

// Bad
const { a, b } = obj

Variables

Prefer const over let. Use ternaries or early returns instead of reassignment.

// Good
const foo = condition ? 1 : 2

// Bad
let foo
if (condition) foo = 1
else foo = 2

Control Flow

Avoid else statements. Prefer early returns.

// Good
function foo() {
  if (condition) return 1
  return 2
}

// Bad
function foo() {
  if (condition) return 1
  else return 2
}

Schema Definitions (Drizzle)

Use snake_case for field names so column names don't need to be redefined as strings.

// Good
const table = sqliteTable("session", {
  id: text().primaryKey(),
  project_id: text().notNull(),
  created_at: integer().notNull(),
})

// Bad
const table = sqliteTable("session", {
  id: text("id").primaryKey(),
  projectID: text("project_id").notNull(),
  createdAt: integer("created_at").notNull(),
})

Testing

• Avoid mocks as much as possible
• Test actual implementation, do not duplicate logic into tests
• Tests cannot run from repo root (guard: do-not-run-tests-from-root); run from package dirs like packages/deeprise.
• Always run the app to verify there are nor errors
• For web apps, ALWAYS use Playwright end-to-end tests (bun run test:e2e from the app package); for backend or library changes, use the narrowest targeted test or package check.
• Never claim tests pass or the app is ready without VERIFICATION EVIDENCE: paste the exact command, exit code, and output summary.
• You must test the app after creating a new app or after changing the code at any level, even if the user doesn't explicitly ask you to.
• Add the test to TODO list if it's not already there, and make sure to mark it done after implementing it.

Type Checking

• Always run bun typecheck from package directories (e.g., packages/deeprise), never tsc directly.

Change Verification

• When you change code, verify it with the narrowest appropriate test or runtime check before you finish.
• For web apps, run Playwright (bun run test:e2e) and attach command output as evidence. Do not report ready without Playwright exit 0.
• If a test, smoke check, or runtime check fails, fix the issue and rerun the same verification until it passes or you hit a real blocker.
• Skip this only for purely informational requests or changes that do not affect code behavior.