@liquidmetal-ai/raindrop 0.9.6 → 0.10.0

package/bundle/commands/object/list.js

@@ -1,6 +1,6 @@
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   ListObjectsResponseSchema,
   __toESM,
@@ -8,7 +8,7 @@ import {
   require_lib,
   timestampDate,
   toJsonString
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/object/list.ts
 init_cjs_shims();
@@ -188,27 +188,93 @@ List objects in my-bucket within my-app
       console.log("No objects found in bucket");
       return;
     }
+    const { client: searchAgent } = await this.searchAgentService();
+    const statusMap = /* @__PURE__ */ new Map();
+    try {
+      const bulkStatusResponse = await searchAgent.getDocumentStatusBulk({
+        userId,
+        organizationId,
+        bucketLocation,
+        objectIds: response.objects.map((obj) => obj.key)
+      });
+      for (const docStatus of bulkStatusResponse.documents) {
+        let indexingStatus = "unknown";
+        if (docStatus.status === "not_found") {
+          indexingStatus = "not started";
+        } else if (docStatus.status === "completed") {
+          indexingStatus = "completed";
+        } else if (docStatus.status === "failed") {
+          const errorMsg = docStatus.errors.length > 0 ? ` (${docStatus.errors[0]})` : "";
+          indexingStatus = `failed${errorMsg}`;
+        } else if (docStatus.status === "partial") {
+          const errorMsg = docStatus.errors.length > 0 ? ` (${docStatus.errors[0]})` : "";
+          indexingStatus = `partial${errorMsg}`;
+        } else if (docStatus.status === "ingesting") {
+          const chunks = docStatus.ingest?.totalChunksCreated || 0;
+          indexingStatus = `ingesting (${chunks} chunks)`;
+        } else if (docStatus.status === "processing") {
+          const stages = [
+            { name: "embedding", info: docStatus.embedding },
+            { name: "vector index", info: docStatus.vectorIndex },
+            { name: "pii", info: docStatus.pii },
+            { name: "relationships", info: docStatus.relationships }
+          ];
+          const activeStage = stages.find((s) => s.info && s.info.itemsRemaining > 0);
+          if (activeStage && activeStage.info) {
+            const progress = activeStage.info.totalExpected - activeStage.info.itemsRemaining;
+            const total = activeStage.info.totalExpected;
+            indexingStatus = `processing ${activeStage.name} (${progress}/${total})`;
+          } else {
+            const hasInitializedStages = stages.some((s) => s.info && s.info.totalExpected > 0);
+            if (!hasInitializedStages) {
+              const chunks = docStatus.ingest?.totalChunksCreated || 0;
+              const queued = docStatus.ingest?.chunksQueued || 0;
+              indexingStatus = `processing (${chunks} chunks created, ${queued} queued)`;
+            } else {
+              indexingStatus = "processing";
+            }
+          }
+        } else {
+          indexingStatus = docStatus.status;
+        }
+        statusMap.set(docStatus.objectId, indexingStatus);
+      }
+    } catch (error) {
+      console.error("Failed to fetch bulk status:", error);
+    }
+    const objectsWithStatus = response.objects.map((obj) => ({
+      ...obj,
+      indexingStatus: statusMap.get(obj.key) || "unknown"
+    }));
     switch (this.flags.output) {
-      case "json":
-        console.log(toJsonString(ListObjectsResponseSchema, response, { prettySpaces: 2 }));
+      case "json": {
+        const jsonResponse = JSON.parse(toJsonString(ListObjectsResponseSchema, response));
+        jsonResponse.objects = objectsWithStatus.map((obj, index) => ({
+          ...jsonResponse.objects[index],
+          indexingStatus: obj.indexingStatus
+        }));
+        console.log(JSON.stringify(jsonResponse, null, 2));
         break;
+      }
       case "table":
         console.table(
-          response.objects.map((obj) => ({
+          objectsWithStatus.map((obj) => ({
             key: obj.key,
             size: obj.size,
             contentType: obj.contentType,
-            lastModified: obj.lastModified ? timestampDate(obj.lastModified).toUTCString() : "N/A"
+            lastModified: obj.lastModified ? timestampDate(obj.lastModified).toUTCString() : "N/A",
+            indexing: obj.indexingStatus
           }))
         );
         break;
       default:
-        for (const obj of response.objects) {
+        for (const obj of objectsWithStatus) {
           const lastModified = obj.lastModified ? timestampDate(obj.lastModified).toUTCString() : "N/A";
           console.log(`Key: ${obj.key}`);
           console.log(`  Size: ${obj.size} bytes`);
           console.log(`  Content-Type: ${obj.contentType || "N/A"}`);
           console.log(`  Last Modified: ${lastModified}`);
+          console.log(`  Indexing: ${obj.indexingStatus}`);
           console.log("---");
         }
     }

package/bundle/commands/object/put.js

@@ -1,13 +1,13 @@
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   PutObjectResponseSchema,
   __toESM,
   init_cjs_shims,
   require_lib,
   toJsonString
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/object/put.ts
 init_cjs_shims();

package/bundle/commands/query/chunk-search.js

@@ -1,16 +1,16 @@
 import {
   ulid
-} from "../../chunk-T3VHOMDJ.js";
+} from "../../chunk-JENN4EVA.js";
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   RagSearchResponseSchema,
   __toESM,
   init_cjs_shims,
   require_lib,
   toJsonString
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/query/chunk-search.ts
 init_cjs_shims();

package/bundle/commands/query/document.js

@@ -1,16 +1,16 @@
 import {
   ulid
-} from "../../chunk-T3VHOMDJ.js";
+} from "../../chunk-JENN4EVA.js";
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   DocumentChatResponseSchema,
   __toESM,
   init_cjs_shims,
   require_lib,
   toJsonString
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/query/document.ts
 init_cjs_shims();

package/bundle/commands/query/events.js

@@ -1,12 +1,12 @@
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   __toESM,
   init_cjs_shims,
   require_lib,
   valueOf
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/query/events.ts
 init_cjs_shims();

package/bundle/commands/query/reindex.js

@@ -1,11 +1,11 @@
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   __toESM,
   init_cjs_shims,
   require_lib
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/query/reindex.ts
 init_cjs_shims();

package/bundle/commands/query/search.js

@@ -1,14 +1,14 @@
 import {
   ulid
-} from "../../chunk-T3VHOMDJ.js";
+} from "../../chunk-JENN4EVA.js";
 import {
   BaseCommand
-} from "../../chunk-OHP3SQGY.js";
+} from "../../chunk-4U2CSHCN.js";
 import {
   __toESM,
   init_cjs_shims,
   require_lib
-} from "../../chunk-YWKX37S2.js";
+} from "../../chunk-WDR5M2SS.js";
 
 // src/commands/query/search.ts
 init_cjs_shims();

package/bundle/commands/tail.js

@@ -1,9 +1,9 @@
 import {
   BaseCommand
-} from "../chunk-OHP3SQGY.js";
+} from "../chunk-4U2CSHCN.js";
 import {
   init_cjs_shims
-} from "../chunk-YWKX37S2.js";
+} from "../chunk-WDR5M2SS.js";
 
 // src/commands/tail.ts
 init_cjs_shims();

package/bundle/index.js

@@ -23,7 +23,7 @@ import {
   serviceClient,
   versionInterceptor,
   workosIntegrationService
-} from "./chunk-YWKX37S2.js";
+} from "./chunk-WDR5M2SS.js";
 var export_run = import_core.run;
 export {
   EPOCH_TS,

package/dist/build.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build.test.d.ts.map

package/dist/build.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.test.d.ts","sourceRoot":"","sources":["../src/build.test.ts"],"names":[],"mappings":""}

package/dist/build.test.js

@@ -0,0 +1,46 @@
+import { expect, test } from 'vitest';
+// import * as fs from 'node:fs/promises';
+// import * as os from 'node:os';
+// import * as path from 'node:path';
+// import build from './build.js';
+test('dummy', () => {
+    expect(true).toBe(true);
+});
+// TODO [bosgood] Days have been spent on this test, and it's still not working in CI
+// Moving on for the moment.
+// const ENTRY_POINT = `
+// console.log('Hello, world!');
+// `;
+// const TSCONFIG = `
+// {
+//   "compilerOptions": {
+//     "target": "ESNext",
+//     "module": "ESNext",
+//     "moduleResolution": "Node",
+//     "esModuleInterop": true,
+//     "skipLibCheck": true,
+//     "forceConsistentCasingInFileNames": true,
+//     "strict": true,
+//     "isolatedModules": true,
+//     "allowSyntheticDefaultImports": true,
+//     "resolveJsonModule": true,
+//     "jsx": "react-jsx",
+//     "outDir": "dist"
+//   }
+// }
+// `;
+// test('build', async () => {
+//   const root = await fs.mkdtemp(path.join(os.tmpdir(), 'build-test'));
+//   const srcDir = path.join(root, 'src');
+//   await fs.mkdir(srcDir);
+//   const tsconfig = path.join(root, 'tsconfig.json');
+//   const entryPoint = path.join(root, 'src', 'index.ts');
+//   await fs.writeFile(entryPoint, ENTRY_POINT);
+//   await fs.writeFile(tsconfig, TSCONFIG);
+//   await build({
+//     root,
+//     entryPoints: [entryPoint],
+//     outdir: path.join(root, 'dist'),
+//   });
+//   expect(await fs.readdir(path.join(root, 'dist'))).toContain('index.js');
+// });

package/dist/codegen.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=codegen.test.d.ts.map

package/dist/codegen.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.test.d.ts","sourceRoot":"","sources":["../src/codegen.test.ts"],"names":[],"mappings":""}

package/dist/codegen.test.js

@@ -0,0 +1,223 @@
+import { mustManifestFromString } from '@liquidmetal-ai/drizzle/appify/index';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { expect, test } from 'vitest';
+import { codegenPlan, gatherEnvForHandler, kebabCaseToCamelCase, kebabCaseToConstantCase, kebabCaseToUpperCamelCase, renderTemplatesFromDirectory, shouldWriteTemplate, trimTemplateSuffix, } from './codegen.js';
+test('trims handlebars suffix', async () => {
+    expect(trimTemplateSuffix('index.ts.hbs')).toEqual('index.ts');
+});
+test('codegens from blank app', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {}
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(1);
+    expect(plan[0]?.templateName).toMatch('templates/init');
+    expect(plan[0]?.outPath).toEqual('');
+});
+test('codegens from app with observer', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      bucket "bucket" {}
+
+      observer "process" {
+        source {
+          bucket = "bucket"
+        }
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/bucket-event-notification');
+    expect(plan[1]?.outPath).toEqual('src/process');
+});
+test('codegens from app with service', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      bucket "bucket" {}
+
+      service "ingester" {
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/http-service');
+    expect(plan[1]?.outPath).toEqual('src/ingester');
+});
+test('codegens from app with durable object', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      actor "ingest-object" {
+      }
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(2);
+    expect(plan[1]?.templateName).toMatch('templates/handlers/actor');
+    expect(plan[1]?.outPath).toEqual('src/ingest-object');
+});
+test('codegens from app with sql database', async () => {
+    const apps = await mustManifestFromString(`
+    application "ingest" {
+      sql_database "demosql" {}
+    }
+  `);
+    const plan = codegenPlan(apps);
+    expect(Object.keys(plan)).toHaveLength(6);
+    expect(plan[0]?.templateName).toMatch('templates/init');
+    expect(plan[0]?.outPath).toEqual('');
+    expect(plan[1]?.templateName).toMatch('templates/db/package.json');
+    expect(plan[1]?.outPath).toEqual('./');
+    expect(plan[2]?.templateName).toMatch('templates/db/db');
+    expect(plan[2]?.outPath).toEqual('db/demosql');
+    expect(plan[3]?.templateName).toMatch('templates/db/common');
+    expect(plan[3]?.outPath).toEqual('src/common');
+    expect(plan[4]?.templateName).toMatch('templates/db/prisma');
+    expect(plan[4]?.outPath).toEqual('prisma/demosql');
+    expect(plan[5]?.templateName).toMatch('templates/db/scripts');
+    expect(plan[5]?.outPath).toEqual('scripts');
+});
+test('only codegens scaffolding when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderScaffoldingCode: true,
+    }, 'src/handlers/something/__index.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderScaffoldingCode: false,
+    }, 'src/handlers/something/__index.ts')).toBe(false);
+});
+test('only codegens user modifiable code when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderUserModifiableCode: true,
+    }, 'src/handlers/something/index.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderUserModifiableCode: false,
+    }, 'src/handlers/something/index.ts')).toBe(false);
+});
+test('only codegens non-user modifiable code when enabled', () => {
+    expect(shouldWriteTemplate({
+        renderNonUserModifiableCode: true,
+    }, 'src/handlers/something/env.gen.d.ts')).toBe(true);
+    expect(shouldWriteTemplate({
+        renderNonUserModifiableCode: false,
+    }, 'src/handlers/something/env.gen.d.ts')).toBe(false);
+});
+test('codegens template files', async () => {
+    const templatePath = path.join(__dirname, '..', 'templates', 'init');
+    const outPath = await fs.mkdtemp(path.join(os.tmpdir(), 'codegen-test'));
+    await renderTemplatesFromDirectory({
+        templatePath,
+        outPath,
+        context: {
+            toolName: 'raindrop',
+            applicationName: 'test-app',
+            raindropFrameworkVersion: '0.4.9',
+        },
+        opts: {
+            renderScaffoldingCode: true,
+            renderUserModifiableCode: true,
+            renderNonUserModifiableCode: true,
+        },
+    });
+    // Verify nested directory structure is preserved
+    const authFilePath = path.join(outPath, 'src', '_app', 'auth.ts');
+    const authFileExists = await fs.access(authFilePath).then(() => true, () => false);
+    expect(authFileExists).toBe(true);
+    // Verify the file content was copied correctly
+    const authFileContent = await fs.readFile(authFilePath, 'utf-8');
+    expect(authFileContent).toContain('verifyIssuer');
+    expect(authFileContent).toContain('requireAuthenticated');
+});
+test('kebabCaseToConstantCase', () => {
+    expect(kebabCaseToConstantCase('my-variable')).toEqual('MY_VARIABLE');
+});
+test('kebabCaseToCamelCase', () => {
+    expect(kebabCaseToCamelCase('my-variable')).toEqual('myVariable');
+});
+test('kebabCaseToUpperCamelCase', () => {
+    expect(kebabCaseToUpperCamelCase('my-variable')).toEqual('MyVariable');
+});
+test('generates SmartMemory type bindings', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      smartmemory "user-memory" {}
+
+      service "test-service" {}
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include SmartMemory import
+    expect(generated).toMatch(/import\s+{[^}]*SmartMemory[^}]*}\s+from\s+'@liquidmetal-ai\/raindrop-framework'/);
+    // Should include SmartMemory type binding with constant case naming
+    expect(generated).toMatch(/USER_MEMORY:\s*SmartMemory/);
+});
+test('generates SmartBucket type bindings', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      smartbucket "data-bucket" {}
+
+      service "test-service" {}
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include SmartBucket import
+    expect(generated).toMatch(/import\s+{[^}]*SmartBucket[^}]*}\s+from\s+'@liquidmetal-ai\/raindrop-framework'/);
+    // Should include SmartBucket type binding with constant case naming
+    expect(generated).toMatch(/DATA_BUCKET:\s*SmartBucket/);
+});
+test('always includes mem KvCache binding', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      service "test-service" {}
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include KvCache import
+    expect(generated).toMatch(/import\s+{[^}]*KvCache[^}]*}\s+from\s+'@liquidmetal-ai\/raindrop-framework'/);
+    // Should include mem type binding
+    expect(generated).toMatch(/mem:\s*KvCache/);
+});
+test('includes auth env vars for protected service', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      service "protected-service" {
+        visibility = "protected"
+      }
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should include core auth bindings and WorkOS provider bindings for protected services
+    expect(generated).toMatch(/LM_AUTH_ALLOWED_ORIGINS:\s*string/);
+    expect(generated).toMatch(/LM_AUTH_ALLOWED_ISSUERS:\s*string/);
+    expect(generated).toMatch(/LM_PROVIDER_WORKOS_ORG_ID\?:\s*string/);
+    expect(generated).toMatch(/LM_PROVIDER_WORKOS_CLIENT_ID\?:\s*string/);
+    expect(generated).toMatch(/LM_PROVIDER_WORKOS_API_KEY\?:\s*string/);
+});
+test('does not include auth env vars for public service', async () => {
+    const apps = await mustManifestFromString(`
+    application "test-app" {
+      service "public-service" {
+        visibility = "public"
+      }
+    }
+  `);
+    const app = apps[0];
+    const service = app.service[0];
+    const generated = gatherEnvForHandler(service, app);
+    // Should NOT include auth env vars for non-protected services
+    expect(generated).not.toMatch(/LM_AUTH_ALLOWED_ORIGINS/);
+    expect(generated).not.toMatch(/LM_AUTH_ALLOWED_ISSUERS/);
+    expect(generated).not.toMatch(/LM_PROVIDER_WORKOS_ORG_ID/);
+    expect(generated).not.toMatch(/LM_PROVIDER_WORKOS_CLIENT_ID/);
+    expect(generated).not.toMatch(/LM_PROVIDER_WORKOS_API_KEY/);
+});

package/dist/commands/logs/tail.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tail.test.d.ts.map

package/dist/commands/logs/tail.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tail.test.d.ts","sourceRoot":"","sources":["../../../src/commands/logs/tail.test.ts"],"names":[],"mappings":""}