@hasna/connectors 1.3.43 → 1.3.45

package/connectors/windmill/src/utils/output.ts

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+
+export type OutputFormat = 'json' | 'table' | 'pretty';
+
+export function formatOutput(data: unknown, format: OutputFormat = 'pretty'): string {
+  switch (format) {
+    case 'json':
+      return JSON.stringify(data, null, 2);
+    case 'table':
+      return formatAsTable(data);
+    case 'pretty':
+    default:
+      return formatPretty(data);
+  }
+}
+
+function formatAsTable(data: unknown): string {
+  if (!Array.isArray(data)) {
+    data = [data];
+  }
+
+  const items = data as Record<string, unknown>[];
+  if (items.length === 0) {
+    return 'No data';
+  }
+
+  const firstItem = items[0];
+  if (!firstItem || typeof firstItem !== 'object') {
+    return 'No data';
+  }
+
+  const keys = Object.keys(firstItem);
+  const colWidths = keys.map(key => {
+    const maxValue = Math.max(
+      key.length,
+      ...items.map(item => String(item[key] ?? '').length)
+    );
+    return Math.min(maxValue, 40);
+  });
+
+  const header = keys.map((key, i) => key.padEnd(colWidths[i] ?? 10)).join(' | ');
+  const separator = colWidths.map(w => '-'.repeat(w)).join('-+-');
+
+  const rows = items.map(item =>
+    keys.map((key, i) => {
+      const value = String(item[key] ?? '');
+      const width = colWidths[i] ?? 10;
+      return value.length > width
+        ? value.substring(0, width - 3) + '...'
+        : value.padEnd(width);
+    }).join(' | ')
+  );
+
+  return [header, separator, ...rows].join('\n');
+}
+
+function formatPretty(data: unknown): string {
+  if (Array.isArray(data)) {
+    return data.map((item, i) => `${chalk.cyan(`[${i + 1}]`)} ${formatPrettyItem(item)}`).join('\n\n');
+  }
+  return formatPrettyItem(data);
+}
+
+function formatPrettyItem(item: unknown, indent = 0): string {
+  if (item === null || item === undefined) {
+    return chalk.gray('null');
+  }
+
+  if (typeof item !== 'object') {
+    return String(item);
+  }
+
+  const spaces = '  '.repeat(indent);
+  const entries = Object.entries(item as Record<string, unknown>);
+
+  return entries
+    .map(([key, value]) => {
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          return `${spaces}${chalk.blue(key)}: ${chalk.gray('[]')}`;
+        }
+        if (typeof value[0] === 'object') {
+          return `${spaces}${chalk.blue(key)}:\n${value.map(v => formatPrettyItem(v, indent + 1)).join('\n')}`;
+        }
+        return `${spaces}${chalk.blue(key)}: ${value.join(', ')}`;
+      }
+
+      if (typeof value === 'object' && value !== null) {
+        return `${spaces}${chalk.blue(key)}:\n${formatPrettyItem(value, indent + 1)}`;
+      }
+
+      return `${spaces}${chalk.blue(key)}: ${chalk.white(String(value))}`;
+    })
+    .join('\n');
+}
+
+export function success(message: string): void {
+  console.log(chalk.green('✓'), message);
+}
+
+export function error(message: string): void {
+  console.error(chalk.red('✗'), message);
+}
+
+export function warn(message: string): void {
+  console.warn(chalk.yellow('⚠'), message);
+}
+
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+export function heading(message: string): void {
+  console.log(chalk.bold.cyan(`\n${message}\n`));
+}
+
+export function print(data: unknown, format: OutputFormat = 'pretty'): void {
+  console.log(formatOutput(data, format));
+}

package/connectors/windmill/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "bin"]
+}

package/connectors/withai/.env.example

@@ -0,0 +1,7 @@
+# WithAI API credentials
+# Get your API key from https://withai.co
+
+WITHAI_API_KEY=your-api-key-here
+
+# Optional: override API base URL (default: https://api.withai.co/v1)
+# WITHAI_BASE_URL=https://api.withai.co/v1

package/connectors/withai/CLAUDE.md

@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with code in this repository.
+
+## Project Overview
+
+connect-withai is a TypeScript connector for the WithAI API. It provides a CLI and library for asset-manager command center operations: workspaces, research tasks, document search, portfolio alerts, and integrations.
+
+## Build & Run Commands
+
+```bash
+bun install           # Install dependencies
+bun run dev           # Run CLI in development
+bun run build         # Build for distribution
+bun run typecheck     # Type check
+bun test              # Run connector tests
+bun run dev -- --help # Show CLI help
+```
+
+## API Details
+
+- **Base URL**: `https://api.withai.co/v1` (configurable via `WITHAI_BASE_URL`)
+- **Auth**: Bearer token: `Authorization: Bearer <API_KEY>`
+- **Docs**: https://withai.co
+
+## API Resources
+
+| Resource | Endpoints | Description |
+|----------|-----------|-------------|
+| Workspaces | `/workspaces` | List and retrieve workspaces |
+| Research Tasks | `/workspaces/:id/research-tasks`, `/research-tasks/:id` | Create and monitor research tasks |
+| Documents | `/documents/search` | Search documents across workspaces |
+| Portfolio | `/portfolio/alerts` | Create portfolio alerts |
+| Integrations | `/integrations` | List connected integrations |
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `WITHAI_API_KEY` | API key (overrides profile config) |
+| `WITHAI_BASE_URL` | Optional API base URL override |
+
+## CLI Commands
+
+```bash
+connect-withai workspaces list
+connect-withai workspaces get <workspaceId>
+connect-withai research-tasks create <workspaceId> --ticker MSFT --prompt "update model"
+connect-withai research-tasks get <taskId>
+connect-withai documents search --search-text "channel checks" --filters '{"ticker":"MSFT"}'
+connect-withai portfolio alerts create --ticker MSFT --threshold "guidance change"
+connect-withai integrations list
+connect-withai raw --path /custom/command-center --method POST --body '{"enabled":true}'
+connect-withai config set-key <key>
+connect-withai profile list
+```
+
+## Code Style
+
+- TypeScript with strict mode
+- ESM modules (type: module)
+- Bun runtime

package/connectors/withai/README.md

@@ -0,0 +1,50 @@
+# @hasna/connect-withai
+
+TypeScript connector for the [WithAI](https://withai.co) API — asset-manager command center for workspaces, research tasks, document search, portfolio alerts, and integrations.
+
+## Install
+
+```bash
+bun install
+```
+
+## Configuration
+
+```bash
+export WITHAI_API_KEY=your-api-key
+# optional
+export WITHAI_BASE_URL=https://api.withai.co/v1
+```
+
+Or use profiles:
+
+```bash
+bun run dev config set-key your-api-key
+```
+
+## Usage
+
+### CLI
+
+```bash
+bun run dev workspaces list
+bun run dev workspaces get ws-123
+bun run dev research-tasks create ws-123 --ticker MSFT --prompt "update model"
+bun run dev research-tasks get task-456
+bun run dev documents search --search-text "earnings" --filters '{"ticker":"MSFT"}'
+bun run dev portfolio alerts create --ticker MSFT --threshold "guidance change"
+bun run dev integrations list
+```
+
+### Library
+
+```typescript
+import { WithAi } from '@hasna/connect-withai';
+
+const api = WithAi.fromEnv();
+const workspaces = await api.listWorkspaces({ firm: 'alpha' });
+```
+
+## License
+
+Apache-2.0

package/connectors/withai/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@hasna/connect-withai",
+  "version": "0.0.1",
+  "description": "WithAI connector - asset-manager command center API",
+  "type": "module",
+  "bin": {
+    "connect-withai": "./bin/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
+    "dev": "bun run ./src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run build",
+    "release": "bun run scripts/release.ts",
+    "release:dry": "bun run scripts/release.ts --dry-run"
+  },
+  "keywords": [
+    "api",
+    "connector",
+    "withai",
+    "ai",
+    "asset-management",
+    "research",
+    "cli",
+    "typescript",
+    "bun"
+  ],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/open-connectors.git"
+  }
+}

package/connectors/withai/scripts/release.ts

@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+/**
+ * Release script for publishing to npm
+ *
+ * Usage:
+ *   bun run release        # Build, bump version, and publish
+ *   bun run release:dry    # Dry run (preview only)
+ *
+ * Features:
+ *   - Auto-fetches current npm version
+ *   - Bumps patch version if needed
+ *   - Creates git tag
+ *   - Publishes to npm
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+
+const isDryRun = process.argv.includes('--dry-run');
+
+interface PackageJson {
+  name: string;
+  version: string;
+  [key: string]: unknown;
+}
+
+function exec(command: string, silent = false): string {
+  try {
+    const result = execSync(command, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : 'inherit',
+    });
+    return result?.trim() || '';
+  } catch (err) {
+    if (silent) {
+      return '';
+    }
+    throw err;
+  }
+}
+
+function log(message: string): void {
+  console.log(`\x1b[36m▸\x1b[0m ${message}`);
+}
+
+function success(message: string): void {
+  console.log(`\x1b[32m✓\x1b[0m ${message}`);
+}
+
+function warn(message: string): void {
+  console.log(`\x1b[33m⚠\x1b[0m ${message}`);
+}
+
+function error(message: string): void {
+  console.error(`\x1b[31m✗\x1b[0m ${message}`);
+}
+
+function parseVersion(version: string): { major: number; minor: number; patch: number } {
+  const [major, minor, patch] = version.split('.').map(Number);
+  return { major, minor, patch };
+}
+
+function bumpPatch(version: string): string {
+  const { major, minor, patch } = parseVersion(version);
+  return `${major}.${minor}.${patch + 1}`;
+}
+
+async function main(): Promise<void> {
+  // Read package.json
+  const packageJsonPath = 'package.json';
+  const packageJson: PackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  const { name, version: localVersion } = packageJson;
+
+  log(`Package: ${name}`);
+  log(`Local version: ${localVersion}`);
+
+  // Get current npm version
+  let npmVersion = '';
+  try {
+    npmVersion = exec(`npm view ${name} version 2>/dev/null`, true);
+    log(`npm version: ${npmVersion || 'not published'}`);
+  } catch {
+    log('npm version: not published yet');
+  }
+
+  // Determine new version
+  let newVersion = localVersion;
+  if (npmVersion) {
+    const localParsed = parseVersion(localVersion);
+    const npmParsed = parseVersion(npmVersion);
+
+    // If local version <= npm version, bump from npm version
+    if (
+      localParsed.major < npmParsed.major ||
+      (localParsed.major === npmParsed.major && localParsed.minor < npmParsed.minor) ||
+      (localParsed.major === npmParsed.major &&
+        localParsed.minor === npmParsed.minor &&
+        localParsed.patch <= npmParsed.patch)
+    ) {
+      newVersion = bumpPatch(npmVersion);
+    }
+  }
+
+  if (newVersion !== localVersion) {
+    log(`Bumping version: ${localVersion} → ${newVersion}`);
+
+    if (!isDryRun) {
+      packageJson.version = newVersion;
+      writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+    }
+  } else {
+    log(`Version unchanged: ${newVersion}`);
+  }
+
+  // Run typecheck
+  log('Running typecheck...');
+  if (!isDryRun) {
+    exec('bun run typecheck');
+    success('Typecheck passed');
+  }
+
+  // Build
+  log('Building...');
+  if (!isDryRun) {
+    exec('bun run build');
+    success('Build completed');
+  }
+
+  // Git operations
+  const gitStatus = exec('git status --porcelain', true);
+  if (gitStatus) {
+    log('Staging changes...');
+    if (!isDryRun) {
+      exec('git add package.json');
+      exec(`git commit -m "chore: release v${newVersion}"`);
+    }
+  }
+
+  // Create git tag
+  const tagName = `v${newVersion}`;
+  log(`Creating tag: ${tagName}`);
+  if (!isDryRun) {
+    try {
+      exec(`git tag ${tagName}`);
+      success(`Tag ${tagName} created`);
+    } catch {
+      warn(`Tag ${tagName} already exists`);
+    }
+  }
+
+  // Publish
+  log('Publishing to npm...');
+  if (isDryRun) {
+    warn('Dry run - skipping publish');
+    exec('npm publish --dry-run');
+  } else {
+    exec('npm publish');
+    success(`Published ${name}@${newVersion}`);
+  }
+
+  // Push tags
+  if (!isDryRun) {
+    log('Pushing tags...');
+    try {
+      exec('git push --tags');
+      success('Tags pushed');
+    } catch {
+      warn('Failed to push tags (you may need to push manually)');
+    }
+  }
+
+  console.log('');
+  success(`Release ${isDryRun ? '(dry run) ' : ''}complete: ${name}@${newVersion}`);
+}
+
+main().catch((err) => {
+  error(String(err));
+  process.exit(1);
+});

package/connectors/withai/src/api/client.test.ts

@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { WithAiClient } from './client';
+import { WithAi } from './index';
+
+const originalFetch = globalThis.fetch;
+let captured: Array<{ url: string; init?: RequestInit; body?: unknown }> = [];
+
+function urlOf(input: string | URL | Request): string {
+  if (typeof input === 'string') return input;
+  if (input instanceof URL) return input.toString();
+  return input.url;
+}
+
+function jsonBody(init?: RequestInit): unknown {
+  if (typeof init?.body !== 'string') return undefined;
+  return JSON.parse(init.body);
+}
+
+describe('WithAiClient', () => {
+  beforeEach(() => {
+    captured = [];
+    globalThis.fetch = mock(async (input: string | URL | Request, init?: RequestInit) => {
+      captured.push({ url: urlOf(input), init, body: jsonBody(init) });
+      return Response.json({ ok: true, connector: 'withai' });
+    }) as unknown as typeof fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    captured = [];
+  });
+
+  test('requires api key', () => {
+    expect(() => new WithAiClient({ apiKey: '' })).toThrow('API key or token is required');
+  });
+
+  test('builds default base URL', () => {
+    const client = new WithAiClient({ apiKey: 'withai-key' });
+    expect(client.buildUrl('/workspaces')).toBe('https://api.withai.co/v1/workspaces');
+  });
+
+  test('encodes path segments in URLs', () => {
+    const client = new WithAiClient({ apiKey: 'withai-key' });
+    expect(client.buildUrl('/workspaces/ws%201')).toBe('https://api.withai.co/v1/workspaces/ws%201');
+  });
+});
+
+describe('WithAi connector API', () => {
+  let api: WithAi;
+
+  beforeEach(() => {
+    captured = [];
+    globalThis.fetch = mock(async (input: string | URL | Request, init?: RequestInit) => {
+      captured.push({ url: urlOf(input), init, body: jsonBody(init) });
+      return Response.json({ ok: true, connector: 'withai' });
+    }) as unknown as typeof fetch;
+    api = new WithAi({ apiKey: 'withai-key' });
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    captured = [];
+  });
+
+  test('uses bearer credentials for command-center endpoints', async () => {
+    await api.listWorkspaces({ firm: 'alpha' });
+    await api.getWorkspace('ws 1');
+    await api.createResearchTask('ws 1', { ticker: 'MSFT', prompt: 'update model' });
+    await api.getResearchTask('task 1');
+    await api.searchDocuments({ search_text: 'channel checks', filters: { ticker: 'MSFT' } });
+    await api.createPortfolioAlert({ ticker: 'MSFT', threshold: 'guidance change' });
+    await api.listIntegrations({ status: 'connected' });
+
+    expect(captured.map((request) => [request.init?.method ?? 'GET', request.url])).toEqual([
+      ['GET', 'https://api.withai.co/v1/workspaces?firm=alpha'],
+      ['GET', 'https://api.withai.co/v1/workspaces/ws%201'],
+      ['POST', 'https://api.withai.co/v1/workspaces/ws%201/research-tasks'],
+      ['GET', 'https://api.withai.co/v1/research-tasks/task%201'],
+      ['POST', 'https://api.withai.co/v1/documents/search'],
+      ['POST', 'https://api.withai.co/v1/portfolio/alerts'],
+      ['GET', 'https://api.withai.co/v1/integrations?status=connected'],
+    ]);
+
+    for (const request of captured) {
+      expect(new Headers(request.init?.headers).get('Authorization')).toBe('Bearer withai-key');
+    }
+
+    expect(captured[2].body).toEqual({ ticker: 'MSFT', prompt: 'update model' });
+    expect(captured[4].body).toEqual({ search_text: 'channel checks', filters: { ticker: 'MSFT' } });
+  });
+
+  test('supports raw requests', async () => {
+    await api.rawRequest({
+      path: '/custom/command-center',
+      method: 'POST',
+      body: { enabled: true },
+    });
+
+    expect(captured[0].url).toBe('https://api.withai.co/v1/custom/command-center');
+    expect(captured[0].init?.method).toBe('POST');
+    expect(captured[0].body).toEqual({ enabled: true });
+  });
+
+  test('fromEnv requires WITHAI_API_KEY', () => {
+    const orig = process.env.WITHAI_API_KEY;
+    delete process.env.WITHAI_API_KEY;
+    expect(() => WithAi.fromEnv()).toThrow('WITHAI_API_KEY environment variable is required');
+    if (orig) process.env.WITHAI_API_KEY = orig;
+  });
+});