@lakitu/sdk 0.1.0

package/convex/sandbox/state/index.ts

@@ -0,0 +1,10 @@
+/**
+ * State - File & Edit State Management
+ *
+ * Track file changes, edits, verification, and checkpoints.
+ */
+
+export * as files from "./files";
+export * as checkpoints from "./checkpoints";
+export * as verification from "./verification";
+export * as artifacts from "./artifacts";

package/convex/sandbox/state/verification.actions.ts

@@ -0,0 +1,268 @@
+"use node";
+
+/**
+ * Verification Actions - Node.js Runtime
+ *
+ * Run tests and linters after edits to catch regressions early.
+ * Supports baseline comparisons and rollback on failure.
+ */
+
+import { internalAction } from "../_generated/server";
+import { v } from "convex/values";
+
+// ============================================
+// Types
+// ============================================
+
+interface VerificationResult {
+  success: boolean;
+  checks: Array<{
+    name: string;
+    success: boolean;
+    output?: string;
+    durationMs?: number;
+  }>;
+}
+
+interface TestSuiteResult {
+  success: boolean;
+  exitCode: number | null;
+  output?: string;
+  errors?: string;
+  durationMs: number;
+  timedOut?: boolean;
+  testCommand: string;
+}
+
+interface RegressionReport {
+  hasRegressions: boolean;
+  regressions: string[];
+  fixed: string[];
+  baselineFailureCount: number;
+  currentFailureCount: number;
+}
+
+// ============================================
+// Actions (run actual verification)
+// ============================================
+
+/**
+ * Verify a file after edit (run linter/type checker)
+ */
+export const verifyFile = internalAction({
+  args: {
+    path: v.string(),
+    cwd: v.optional(v.string()),
+  },
+  handler: async (ctx, args): Promise<VerificationResult> => {
+    const cwd = args.cwd || "/home/user/workspace";
+    const results: VerificationResult = {
+      success: true,
+      checks: [],
+    };
+
+    // Determine file type and run appropriate checks
+    const ext = args.path.split(".").pop()?.toLowerCase();
+
+    if (ext === "ts" || ext === "tsx") {
+      // Run TypeScript type check
+      const tscResult = await runCommand("bunx tsc --noEmit", cwd, 30000);
+      results.checks.push({
+        name: "typescript",
+        success: tscResult.exitCode === 0,
+        output: tscResult.stderr || tscResult.stdout,
+        durationMs: tscResult.durationMs,
+      });
+      if (tscResult.exitCode !== 0) results.success = false;
+    }
+
+    if (ext === "js" || ext === "jsx" || ext === "ts" || ext === "tsx") {
+      // Run ESLint
+      const eslintResult = await runCommand(
+        `bunx eslint "${args.path}" --format compact`,
+        cwd,
+        15000
+      );
+      results.checks.push({
+        name: "eslint",
+        success: eslintResult.exitCode === 0,
+        output: eslintResult.stdout,
+        durationMs: eslintResult.durationMs,
+      });
+      // ESLint failures are warnings, not blockers
+    }
+
+    if (ext === "py") {
+      // Run Python type check
+      const mypyResult = await runCommand(`mypy "${args.path}"`, cwd, 30000);
+      results.checks.push({
+        name: "mypy",
+        success: mypyResult.exitCode === 0,
+        output: mypyResult.stdout,
+        durationMs: mypyResult.durationMs,
+      });
+      if (mypyResult.exitCode !== 0) results.success = false;
+    }
+
+    return results;
+  },
+});
+
+/**
+ * Run the test suite and detect regressions
+ */
+export const runTestSuite = internalAction({
+  args: {
+    cwd: v.optional(v.string()),
+    testCommand: v.optional(v.string()),
+    timeoutMs: v.optional(v.number()),
+  },
+  handler: async (ctx, args): Promise<TestSuiteResult> => {
+    const cwd = args.cwd || "/home/user/workspace";
+    const testCommand = args.testCommand || detectTestCommand(cwd);
+    const timeoutMs = args.timeoutMs || 120000; // 2 minutes default
+
+    const result = await runCommand(testCommand, cwd, timeoutMs);
+
+    return {
+      success: result.exitCode === 0,
+      exitCode: result.exitCode,
+      output: result.stdout,
+      errors: result.stderr,
+      durationMs: result.durationMs,
+      timedOut: result.timedOut,
+      testCommand,
+    };
+  },
+});
+
+/**
+ * Compare test results to detect regressions
+ */
+export const compareTestResults = internalAction({
+  args: {
+    baseline: v.any(), // TestSuiteResult
+    current: v.any(), // TestSuiteResult
+  },
+  handler: async (ctx, args): Promise<RegressionReport> => {
+    const baseline = args.baseline as TestSuiteResult;
+    const current = args.current as TestSuiteResult;
+
+    // Parse test output to extract failure names
+    const baselineFailures = parseTestFailures(baseline.output || "");
+    const currentFailures = parseTestFailures(current.output || "");
+
+    // Find new failures (regressions)
+    const regressions = currentFailures.filter(
+      (f) => !baselineFailures.includes(f)
+    );
+
+    // Find fixed tests
+    const fixed = baselineFailures.filter((f) => !currentFailures.includes(f));
+
+    return {
+      hasRegressions: regressions.length > 0,
+      regressions,
+      fixed,
+      baselineFailureCount: baselineFailures.length,
+      currentFailureCount: currentFailures.length,
+    };
+  },
+});
+
+// ============================================
+// Helpers
+// ============================================
+
+async function runCommand(
+  command: string,
+  cwd: string,
+  timeoutMs: number
+): Promise<{
+  exitCode: number | null;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+  timedOut?: boolean;
+}> {
+  const { spawn } = await import("child_process");
+
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const proc = spawn("bash", ["-c", command], {
+      cwd,
+      env: {
+        ...process.env,
+        HOME: "/home/user",
+        PATH: "/home/user/.bun/bin:/usr/local/bin:/usr/bin:/bin",
+      },
+    });
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => proc.kill("SIGKILL"), 1000);
+    }, timeoutMs);
+
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+      if (stdout.length > 50000) stdout = stdout.slice(-50000);
+    });
+
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+      if (stderr.length > 50000) stderr = stderr.slice(-50000);
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: code,
+        stdout,
+        stderr,
+        durationMs: Date.now() - startTime,
+        timedOut,
+      });
+    });
+
+    proc.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: null,
+        stdout,
+        stderr: error.message,
+        durationMs: Date.now() - startTime,
+      });
+    });
+  });
+}
+
+function detectTestCommand(cwd: string): string {
+  // TODO: Actually check for package.json, etc.
+  // For now, default to bun test
+  return "bun test";
+}
+
+function parseTestFailures(output: string): string[] {
+  const failures: string[] = [];
+
+  // Parse common test output formats
+  // Vitest/Jest format: "FAIL path/to/test.ts"
+  const failRegex = /FAIL\s+(.+)/g;
+  let match;
+  while ((match = failRegex.exec(output)) !== null) {
+    failures.push(match[1].trim());
+  }
+
+  // Also look for "✗" or "✕" markers
+  const xRegex = /[✗✕]\s+(.+)/g;
+  while ((match = xRegex.exec(output)) !== null) {
+    failures.push(match[1].trim());
+  }
+
+  return [...new Set(failures)]; // Dedupe
+}

package/convex/sandbox/state/verification.ts

@@ -0,0 +1,101 @@
+/**
+ * Verification - Queries and Mutations
+ *
+ * Store and retrieve verification results.
+ * Actions that run actual verification are in verification.actions.ts
+ */
+
+import { mutation, query } from "../_generated/server";
+import { v } from "convex/values";
+
+// ============================================
+// Mutations (store verification results)
+// ============================================
+
+/**
+ * Store verification result for an edit
+ */
+export const storeResult = mutation({
+  args: {
+    editId: v.optional(v.id("editHistory")),
+    path: v.string(),
+    success: v.boolean(),
+    checks: v.array(
+      v.object({
+        name: v.string(),
+        success: v.boolean(),
+        output: v.optional(v.string()),
+        durationMs: v.optional(v.number()),
+      })
+    ),
+    threadId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.insert("verificationResults", {
+      editId: args.editId,
+      path: args.path,
+      success: args.success,
+      checks: args.checks,
+      threadId: args.threadId,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+/**
+ * Store test suite baseline
+ */
+export const storeBaseline = mutation({
+  args: {
+    threadId: v.string(),
+    result: v.any(), // TestSuiteResult
+  },
+  handler: async (ctx, args) => {
+    // Remove old baselines for this thread
+    const existing = await ctx.db
+      .query("testBaselines")
+      .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
+      .collect();
+
+    for (const baseline of existing) {
+      await ctx.db.delete(baseline._id);
+    }
+
+    return await ctx.db.insert("testBaselines", {
+      threadId: args.threadId,
+      result: args.result,
+      createdAt: Date.now(),
+    });
+  },
+});
+
+// ============================================
+// Queries
+// ============================================
+
+/**
+ * Get verification results for a file
+ */
+export const getResultsForFile = query({
+  args: { path: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("verificationResults")
+      .withIndex("by_path", (q) => q.eq("path", args.path))
+      .order("desc")
+      .take(10);
+  },
+});
+
+/**
+ * Get test baseline for thread
+ */
+export const getBaseline = query({
+  args: { threadId: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("testBaselines")
+      .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
+      .first();
+  },
+});

package/convex/sandbox/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  /* This TypeScript project config describes the environment that
+   * Convex functions run in and is used to typecheck them.
+   * You can modify it, but some settings are required to use Convex.
+   */
+  "compilerOptions": {
+    /* These settings are not required by Convex and can be modified. */
+    "allowJs": true,
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+
+    /* These compiler options are required by Convex */
+    "target": "ESNext",
+    "lib": ["ES2021", "dom"],
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["./**/*"],
+  "exclude": ["./_generated"]
+}

package/convex/sandbox/utils/codeExecHelpers.ts

@@ -0,0 +1,52 @@
+/**
+ * Code Execution Helpers
+ *
+ * Pure functions for parsing and preparing code for execution.
+ * These don't require Node.js APIs.
+ */
+
+/**
+ * Extract code blocks from LLM response text.
+ *
+ * Supports:
+ * - ```typescript ... ```
+ * - ```ts ... ```
+ * - ```javascript ... ```
+ * - ```js ... ```
+ * - ``` ... ``` (unmarked, treated as TypeScript)
+ */
+export function extractCodeBlocks(text: string): string[] {
+  const blocks: string[] = [];
+
+  // Match fenced code blocks
+  const fenceRegex = /```(?:typescript|ts|javascript|js)?\s*\n([\s\S]*?)```/g;
+  let match;
+
+  while ((match = fenceRegex.exec(text)) !== null) {
+    const code = match[1].trim();
+    if (code.length > 0) {
+      blocks.push(code);
+    }
+  }
+
+  return blocks;
+}
+
+/**
+ * Wrap code to ensure it can import from KSAs.
+ *
+ * Adds the necessary import path setup if not already present.
+ */
+export function wrapCodeForExecution(code: string): string {
+  // If code already has imports from KSAs, use it as-is
+  if (code.includes("from './ksa/") || code.includes('from "./ksa/')) {
+    return code;
+  }
+
+  // If code has imports from 'ksa/', adjust the path
+  if (code.includes("from 'ksa/") || code.includes('from "ksa/')) {
+    return code.replace(/from ['"]KSAs\//g, "from './ksa/");
+  }
+
+  return code;
+}

package/dist/cli/commands/build.d.ts

@@ -0,0 +1,19 @@
+/**
+ * lakitu build
+ *
+ * Build E2B sandbox template with pre-deployed Convex functions.
+ *
+ * Strategy:
+ * 1. Start local convex-backend
+ * 2. Deploy sandbox functions with `convex dev --once`
+ * 3. Capture the state directory
+ * 4. Build E2B template with pre-built state baked in
+ */
+interface BuildOptions {
+    base?: boolean;
+    custom?: boolean;
+    baseId?: string;
+}
+export declare function build(options: BuildOptions): Promise<void>;
+export {};
+//# sourceMappingURL=build.d.ts.map

package/dist/cli/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../../cli/commands/build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAWH,UAAU,YAAY;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAyND,wBAAsB,KAAK,CAAC,OAAO,EAAE,YAAY,iBAgBhD"}