orangeslice 2.1.4-beta.1 → 2.1.4

package/dist/cli.js

@@ -48,6 +48,16 @@ const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 const AGENTS_IMPORT_LINE = "@orangeslice-docs/AGENTS.md";
 const CLAUDE_IMPORT_LINE = "@orangeslice-docs/CLAUDE.md";
 const SUPPORTED_RUNNERS = ["npm", "bun", "pnpm", "yarn"];
+function getOwnVersion() {
+    try {
+        const pkgPath = path.join(__dirname, "..", "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        return pkg.version || "latest";
+    }
+    catch {
+        return "latest";
+    }
+}
 function isDir(p) {
     try {
         return fs.statSync(p).isDirectory();
@@ -58,10 +68,8 @@ function isDir(p) {
 }
 function resolveDocsDir() {
     const envSource = process.env.ORANGESLICE_DOCS_SOURCE?.trim();
-    const home = process.env.HOME || "";
     const candidates = [
         envSource || "",
-        home ? path.join(home, "Documents", "Dev", "nextjs-flask", "lib", "vfs", "sheet-chat") : "",
         path.join(process.cwd(), "lib", "vfs", "sheet-chat"),
         path.join(process.cwd(), "sheet-chat"),
         LEGACY_DOCS_DIR
@@ -126,13 +134,15 @@ function getRunnerCommand(packageManager, suffix = "") {
     return suffix ? `${command} ${suffix}` : command;
 }
 function getInstallCommand(packageManager) {
+    const version = getOwnVersion();
+    const spec = version === "latest" ? "orangeslice" : `orangeslice@${version}`;
     if (packageManager === "bun")
-        return "bun add orangeslice";
+        return `bun add ${spec}`;
     if (packageManager === "pnpm")
-        return "pnpm add orangeslice";
+        return `pnpm add ${spec}`;
     if (packageManager === "yarn")
-        return "yarn add orangeslice";
-    return "npm install orangeslice";
+        return `yarn add ${spec}`;
+    return `npm install ${spec}`;
 }
 function getSupportedRunnerExamples() {
     return SUPPORTED_RUNNERS.map((packageManager) => getRunnerCommand(packageManager));
@@ -321,14 +331,14 @@ function getStoredApiKey() {
 function openBrowser(url) {
     try {
         if (process.platform === "darwin") {
-            (0, child_process_1.execSync)(`open "${url}"`, { stdio: "ignore" });
+            (0, child_process_1.execFileSync)("open", [url], { stdio: "ignore" });
             return;
         }
         if (process.platform === "win32") {
-            (0, child_process_1.execSync)(`start "" "${url}"`, { stdio: "ignore", shell: "cmd.exe" });
+            (0, child_process_1.execFileSync)("cmd.exe", ["/c", "start", "", url], { stdio: "ignore" });
             return;
         }
-        (0, child_process_1.execSync)(`xdg-open "${url}"`, { stdio: "ignore" });
+        (0, child_process_1.execFileSync)("xdg-open", [url], { stdio: "ignore" });
     }
     catch {
         console.log(`  Open this URL in your browser:\n  ${url}\n`);

package/dist/ctx.d.ts

@@ -2,18 +2,16 @@
  * Spreadsheet context API for the orangeslice SDK.
  *
  * Usage:
- *   import { services } from "orangeslice";
- *   const { ctx } = services;
+ *   import { ctx } from "orangeslice";
  *
  *   const ss = await ctx.createSpreadsheet({ name: "Leads" });
  *   await ctx.sql(ss.id, 'CREATE TABLE contacts (name, email, website)');
- *   await ctx.sql(ss.id, "INSERT INTO contacts (name, email) VALUES ('Acme', 'hi@acme.com')");
  *   const { rows } = await ctx.sql(ss.id, "SELECT * FROM contacts");
  *
  *   // Or bind to a spreadsheet for convenience:
  *   const bound = ctx.spreadsheet(ss.id);
  *   await bound.sql("SELECT * FROM contacts WHERE name = 'Acme'");
- *   await bound.sheet("contacts").addRow({ name: "Corp", email: "corp@example.com" });
+ *   await bound.sheet("contacts").addRows({ name: "Corp", email: "corp@example.com" });
  */
 export interface Spreadsheet {
     id: string;
@@ -41,12 +39,20 @@ export interface SqlActionResult {
         name: string;
     }>;
 }
+export interface RowsAddResult {
+    success: boolean;
+    rowCount: number;
+    rowIds: string[];
+}
 export type SqlResult = SqlQueryResult | SqlActionResult;
 export declare const ctx: {
     createSpreadsheet: (opts: {
         name: string;
     }) => Promise<Spreadsheet>;
-    listSpreadsheets: () => Promise<{
+    listSpreadsheets: (opts?: {
+        limit?: number;
+        offset?: number;
+    }) => Promise<{
         spreadsheets: SpreadsheetListItem[];
     }>;
     deleteSpreadsheet: (spreadsheetId: string) => Promise<{
@@ -56,8 +62,7 @@ export declare const ctx: {
     spreadsheet: (spreadsheetId: string) => {
         sql: (sql: string) => Promise<SqlResult>;
         sheet: (sheetName: string) => {
-            addRow: (row: Record<string, unknown>) => Promise<SqlResult>;
-            addRows: (rows: Record<string, unknown>[]) => Promise<SqlResult>;
+            addRows: (rows: Record<string, unknown> | Record<string, unknown>[]) => Promise<RowsAddResult>;
         };
     };
 };

package/dist/ctx.js

@@ -3,58 +3,21 @@
  * Spreadsheet context API for the orangeslice SDK.
  *
  * Usage:
- *   import { services } from "orangeslice";
- *   const { ctx } = services;
+ *   import { ctx } from "orangeslice";
  *
  *   const ss = await ctx.createSpreadsheet({ name: "Leads" });
  *   await ctx.sql(ss.id, 'CREATE TABLE contacts (name, email, website)');
- *   await ctx.sql(ss.id, "INSERT INTO contacts (name, email) VALUES ('Acme', 'hi@acme.com')");
  *   const { rows } = await ctx.sql(ss.id, "SELECT * FROM contacts");
  *
  *   // Or bind to a spreadsheet for convenience:
  *   const bound = ctx.spreadsheet(ss.id);
  *   await bound.sql("SELECT * FROM contacts WHERE name = 'Acme'");
- *   await bound.sheet("contacts").addRow({ name: "Corp", email: "corp@example.com" });
+ *   await bound.sheet("contacts").addRows({ name: "Corp", email: "corp@example.com" });
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ctx = void 0;
 const api_1 = require("./api");
 // ---------------------------------------------------------------------------
-// SQL builder helpers
-// ---------------------------------------------------------------------------
-function escapeValue(val) {
-    if (val === null || val === undefined)
-        return "NULL";
-    if (typeof val === "number") {
-        if (!Number.isFinite(val))
-            throw new Error(`[orangeslice] Cannot use ${val} as a SQL value`);
-        return String(val);
-    }
-    if (typeof val === "boolean")
-        return String(val);
-    const str = String(val).replace(/'/g, "''");
-    return `'${str}'`;
-}
-function escapeName(name) {
-    return `"${name.replace(/"/g, '""')}"`;
-}
-function buildInsertSQL(sheetName, rows) {
-    if (rows.length === 0)
-        throw new Error("[orangeslice] addRows requires at least one row");
-    const allKeys = new Set();
-    for (const row of rows) {
-        for (const key of Object.keys(row))
-            allKeys.add(key);
-    }
-    const columns = Array.from(allKeys);
-    const colList = columns.map(escapeName).join(", ");
-    const valueClauses = rows.map((row) => {
-        const vals = columns.map((col) => escapeValue(row[col]));
-        return `(${vals.join(", ")})`;
-    });
-    return `INSERT INTO ${escapeName(sheetName)} (${colList}) VALUES ${valueClauses.join(", ")}`;
-}
-// ---------------------------------------------------------------------------
 // Validation
 // ---------------------------------------------------------------------------
 function assertNotRun(sql) {
@@ -68,13 +31,10 @@ function assertNotRun(sql) {
 // ---------------------------------------------------------------------------
 function createSheetHandle(spreadsheetId, sheetName) {
     return {
-        addRow: (row) => (0, api_1.post)("/ctx/sql", {
-            spreadsheetId,
-            sql: buildInsertSQL(sheetName, [row])
-        }),
-        addRows: (rows) => (0, api_1.post)("/ctx/sql", {
+        addRows: (rows) => (0, api_1.post)("/ctx/rows/add", {
             spreadsheetId,
-            sql: buildInsertSQL(sheetName, rows)
+            sheetName,
+            rows: Array.isArray(rows) ? rows : [rows]
         })
     };
 }
@@ -92,7 +52,7 @@ function createSpreadsheetHandle(spreadsheetId) {
 // ---------------------------------------------------------------------------
 exports.ctx = {
     createSpreadsheet: (opts) => (0, api_1.post)("/ctx/spreadsheet/create", opts),
-    listSpreadsheets: () => (0, api_1.post)("/ctx/spreadsheet/list", {}),
+    listSpreadsheets: (opts) => (0, api_1.post)("/ctx/spreadsheet/list", opts ?? {}),
     deleteSpreadsheet: (spreadsheetId) => (0, api_1.post)("/ctx/spreadsheet/delete", { spreadsheetId }),
     sql: (spreadsheetId, sql) => {
         assertNotRun(sql);

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { configure } from "./api";
 export type { OrangesliceConfig } from "./api";
 export { ctx } from "./ctx";
-export type { Spreadsheet, SpreadsheetListItem, SqlResult, SqlQueryResult, SqlActionResult } from "./ctx";
+export type { Spreadsheet, SpreadsheetListItem, SqlResult, SqlQueryResult, SqlActionResult, RowsAddResult } from "./ctx";
 export { linkedinSearch } from "./b2b";
 export type { LinkedInSearchParams, LinkedInSearchResponse } from "./b2b";
 export { crunchbaseSearch } from "./crunchbase";
@@ -32,25 +32,6 @@ import { generateObject } from "./generateObject";
 import { googleMapsScrape } from "./googleMaps";
 import { webBatchSearch, webSearch } from "./serp";
 export declare const services: {
-    ctx: {
-        createSpreadsheet: (opts: {
-            name: string;
-        }) => Promise<import("./ctx").Spreadsheet>;
-        listSpreadsheets: () => Promise<{
-            spreadsheets: import("./ctx").SpreadsheetListItem[];
-        }>;
-        deleteSpreadsheet: (spreadsheetId: string) => Promise<{
-            success: boolean;
-        }>;
-        sql: (spreadsheetId: string, sql: string) => Promise<import("./ctx").SqlResult>;
-        spreadsheet: (spreadsheetId: string) => {
-            sql: (sql: string) => Promise<import("./ctx").SqlResult>;
-            sheet: (sheetName: string) => {
-                addRow: (row: Record<string, unknown>) => Promise<import("./ctx").SqlResult>;
-                addRows: (rows: Record<string, unknown>[]) => Promise<import("./ctx").SqlResult>;
-            };
-        };
-    };
     crunchbase: {
         search: typeof crunchbaseSearch;
     };

package/dist/index.js

@@ -41,7 +41,6 @@ const apify_2 = require("./apify");
 const b2b_2 = require("./b2b");
 const browser_2 = require("./browser");
 const crunchbase_2 = require("./crunchbase");
-const ctx_2 = require("./ctx");
 const expansion_2 = require("./expansion");
 const firecrawl_2 = require("./firecrawl");
 const generateObject_2 = require("./generateObject");
@@ -49,7 +48,6 @@ const googleMaps_2 = require("./googleMaps");
 const predictLeads_2 = require("./predictLeads");
 const serp_2 = require("./serp");
 exports.services = {
-    ctx: ctx_2.ctx,
     crunchbase: {
         search: crunchbase_2.crunchbaseSearch
     },

package/docs/integrations/attio/assertEntry.md

@@ -0,0 +1,44 @@
+# assertEntry
+
+Create or update a list entry by parent record. If an entry with the specified parent record exists, it is updated. If not found, a new entry is created.
+
+```typescript
+// Attribute slugs in entry_values depend on your list's configuration
+const result = await integrations.attio.assertEntry({
+  list_id: "list_01abc123def456",
+  data: {
+    parent_record_id: "rec_01abc123def456",
+    parent_object: "companies",
+    entry_values: {
+      // Use your list's attribute api_slugs (e.g. "stage", "priority", etc.)
+    },
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  list_id: string;
+  data: {
+    parent_record_id: string;
+    parent_object: string;
+    entry_values: Record<string, any>;
+  };
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { workspace_id: string; entry_id: string; list_id: string };
+    parent_record_id: string;
+    parent_object: string;
+    created_at: string;
+    entry_values: Record<string, Array<{ active_from?: string; active_until?: string | null; attribute_type?: string; [key: string]: any }>>;
+  };
+}
+```

package/docs/integrations/attio/assertRecord.md

@@ -0,0 +1,51 @@
+# assertRecord
+
+Create or update a record by matching attribute (upsert). If a record with the same value for matching_attribute exists, it is updated. Otherwise a new record is created.
+
+```typescript
+const result = await integrations.attio.assertRecord({
+   object: "people",
+   matching_attribute: "email_addresses",
+   data: {
+      values: {
+         email_addresses: [{ email_address: "jane@acme.com" }],
+         name: [{ first_name: "Jane", last_name: "Smith", full_name: "Jane Smith" }],
+         job_title: "CTO"
+      }
+   }
+});
+```
+
+## Input
+
+```typescript
+{
+   object: string;
+   matching_attribute: string;
+   data: {
+      values: Record<string, any>;
+   }
+}
+```
+
+`object` is a path parameter. `matching_attribute` is sent as a query parameter. The `data` wrapper is sent as the request body.
+
+## Output
+
+```typescript
+{
+   data: {
+      id: {
+         workspace_id: string;
+         object_id: string;
+         record_id: string;
+      }
+      created_at: string;
+      web_url: string;
+      values: Record<
+         string,
+         Array<{ active_from?: string; active_until?: string | null; attribute_type?: string; [key: string]: any }>
+      >;
+   }
+}
+```

package/docs/integrations/attio/createAttribute.md

@@ -0,0 +1,59 @@
+# createAttribute
+
+Create an attribute on an object or list.
+
+```typescript
+const result = await integrations.attio.createAttribute({
+  target: "objects",
+  target_identifier: "companies",
+  data: {
+    title: "Annual Revenue",
+    description: "Company annual revenue in USD",
+    api_slug: "annual_revenue",
+    type: "number",
+    is_required: false,
+    is_unique: false,
+    is_multiselect: false,
+    config: { currency: "USD" },
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  target: "objects" | "lists";
+  target_identifier: string;
+  data: {
+    title: string;
+    description: string | null;
+    api_slug: string;
+    type: string;
+    is_required: boolean;
+    is_unique: boolean;
+    is_multiselect: boolean;
+    config: Record<string, any>;
+    default_value?: any;
+    relationship?: Record<string, any>;
+  };
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { attribute_id: string; object_id?: string; list_id?: string };
+    title: string;
+    api_slug: string;
+    type: string;
+    is_required: boolean;
+    is_unique: boolean;
+    is_multiselect: boolean;
+    is_writable: boolean;
+    created_at: string;
+  };
+}
+```

package/docs/integrations/attio/createComment.md

@@ -0,0 +1,60 @@
+# createComment
+
+Create a comment on a record, entry, or as a reply to a thread. Requires an author (workspace member).
+
+```typescript
+// Reply to a thread
+const reply = await integrations.attio.createComment({
+  data: {
+    format: "plaintext",
+    content: "Good point — let's circle back after the demo.",
+    author: { type: "workspace-member", id: "wm_01abc123def456" },
+    thread_id: "thr_01xyz789ghi012",
+  },
+});
+
+// Comment on a record
+const recordComment = await integrations.attio.createComment({
+  data: {
+    format: "plaintext",
+    content: "Reached out via email, waiting on response.",
+    author: { type: "workspace-member", id: "wm_01abc123def456" },
+    record: { object: "companies", record_id: "rec_01abc123def456" },
+  },
+});
+
+// Comment on a list entry
+const entryComment = await integrations.attio.createComment({
+  data: {
+    format: "plaintext",
+    content: "Moved to negotiation stage after last call.",
+    author: { type: "workspace-member", id: "wm_01abc123def456" },
+    entry: { list: "sales_pipeline", entry_id: "ent_01abc123def456" },
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  data:
+    | { format: "plaintext"; content: string; author: { type: "workspace-member"; id: string }; created_at?: string; thread_id: string }
+    | { format: "plaintext"; content: string; author: { type: "workspace-member"; id: string }; created_at?: string; record: { object: string; record_id: string } }
+    | { format: "plaintext"; content: string; author: { type: "workspace-member"; id: string }; created_at?: string; entry: { list: string; entry_id: string } }
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { comment_id: string };
+    thread_id: string;
+    content_plaintext: string;
+    created_at: string;
+    author: { type: string; id: string | null };
+  };
+}
+```

package/docs/integrations/attio/createEntry.md

@@ -0,0 +1,44 @@
+# createEntry
+
+Add a record to a list as a new entry.
+
+```typescript
+// Attribute slugs in entry_values depend on your list's configuration
+const result = await integrations.attio.createEntry({
+  list_id: "list_01abc123def456",
+  data: {
+    parent_record_id: "rec_01abc123def456",
+    parent_object: "companies",
+    entry_values: {
+      // Use your list's attribute api_slugs (e.g. "stage", "notes", etc.)
+    },
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  list_id: string;
+  data: {
+    parent_record_id: string;
+    parent_object: string;
+    entry_values: Record<string, any>;
+  };
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { workspace_id: string; entry_id: string; list_id: string };
+    parent_record_id: string;
+    parent_object: string;
+    created_at: string;
+    entry_values: Record<string, Array<{ active_from?: string; active_until?: string | null; attribute_type?: string; [key: string]: any }>>;
+  };
+}
+```

package/docs/integrations/attio/createFolder.md

@@ -0,0 +1,58 @@
+# createFolder
+
+Create a folder on a record.
+
+```typescript
+const result = await integrations.attio.createFolder({
+  data: {
+    object: "companies",
+    record_id: "rec_01abc123def456",
+    file_type: "folder",
+    name: "Contracts",
+  },
+});
+
+// Create a nested folder
+const nested = await integrations.attio.createFolder({
+  data: {
+    object: "companies",
+    record_id: "rec_01abc123def456",
+    file_type: "folder",
+    name: "2025 Renewals",
+    parent_folder_id: "fil_01xyz789ghi012",
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  data: {
+    object: string;
+    record_id: string;
+    file_type: "folder";
+    name: string;
+    parent_folder_id?: string;
+  };
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { file_id: string };
+    name: string;
+    type: "file" | "folder";
+    mime_type: string | null;
+    size: number | null;
+    parent_folder_id: string | null;
+    record_id: string;
+    object_id: string;
+    storage_provider: string;
+    created_at: string;
+  };
+}
+```

package/docs/integrations/attio/createList.md

@@ -0,0 +1,51 @@
+# createList
+
+Create a new list.
+
+```typescript
+const result = await integrations.attio.createList({
+  data: {
+    name: "Enterprise Prospects",
+    api_slug: "enterprise_prospects",
+    parent_object: "companies",
+    workspace_access: "full-access",
+    workspace_member_access: [
+      { workspace_member_id: "wm_01abc123", level: "full-access" },
+      { workspace_member_id: "wm_01def456", level: "read-only" },
+    ],
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  data: {
+    name: string;
+    api_slug: string;
+    parent_object: string;
+    workspace_access: string | null;
+    workspace_member_access: Array<{
+      workspace_member_id: string;
+      level: "full-access" | "read-and-write" | "read-only";
+    }>;
+  };
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { list_id: string; workspace_id: string };
+    api_slug: string;
+    name: string;
+    parent_object: string[];
+    workspace_access: string;
+    created_by_actor: { type: string; id: string | null };
+    created_at: string;
+  };
+}
+```

package/docs/integrations/attio/createNote.md

@@ -0,0 +1,47 @@
+# createNote
+
+Create a note on a record.
+
+```typescript
+const result = await integrations.attio.createNote({
+  data: {
+    parent_object: "companies",
+    parent_record_id: "rec_01abc123def456",
+    title: "Discovery Call Notes",
+    format: "plaintext",
+    content: "Discussed pricing tiers and implementation timeline. Decision maker is VP of Engineering. Follow up next Tuesday.",
+  },
+});
+```
+
+## Input
+
+```typescript
+{
+  data: {
+    parent_object: string;
+    parent_record_id: string;
+    title: string;
+    format: "plaintext" | "markdown";
+    content: string;
+    created_at?: string;
+    meeting_id?: string | null;
+  };
+}
+```
+
+## Output
+
+```typescript
+{
+  data: {
+    id: { note_id: string };
+    parent_object: string;
+    parent_record_id: string;
+    title: string;
+    content_plaintext: string;
+    created_at: string;
+    created_by_actor: { type: string; id: string | null };
+  };
+}
+```