@basestream/cli 0.1.0

package/README.md

@@ -0,0 +1,380 @@
+# Basestream.ai
+
+**Your team uses AI every day. Now you can see what it's building.**
+
+Basestream is an AI Work Intelligence platform that automatically tracks what developers build with AI tools (Claude Code, Cursor, etc.) and gives engineering teams visibility into AI-powered output.
+
+A product of [Sublevel Inc.](https://sublevel.com)
+
+---
+
+## Quick Start
+
+```bash
+# 1. Start Postgres (from monorepo root — shared with packages/api)
+cd packages/api && docker compose up -d && cd ../basestream
+
+# 2. Install dependencies
+npm install --legacy-peer-deps
+
+# 3. Set up environment
+cp .env.example .env
+# .env is pre-configured for local dev with SKIP_PAYMENT=true
+
+# 4. Push schema to database
+npx drizzle-kit generate
+# Then apply the migration:
+cat src/db/migrations/0000_*.sql | docker exec -i basement-pg psql -U postgres -d basement_starter
+
+# 5. Seed demo data (3 users, 44 entries, 1 org)
+npx tsx src/db/seed.ts
+
+# 6. Run dev server
+npm run dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) to see the landing page.
+
+### End-to-End Local Testing
+
+With `SKIP_PAYMENT=true` in `.env`, you can:
+
+- Sign up via email magic link (check console for the link)
+- Skip Stripe checkout — clicking "Get early access" instantly upgrades to Team
+- Create orgs, invite members, manage integrations
+- Ingest work entries via API key (`POST /api/entries`)
+- Bulk sync entries (`POST /api/sync` — idempotent via sessionId)
+
+---
+
+## Architecture
+
+```
+packages/basestream/
+├── src/
+│   ├── db/
+│   │   ├── schema.ts                # Drizzle schema: 10 tables, 7 enums (bs_ prefixed)
+│   │   ├── index.ts                 # Drizzle client (pg Pool → port 5434)
+│   │   ├── seed.ts                  # Demo: 3 users, 44 entries, 1 org
+│   │   └── migrations/             # Generated SQL migrations
+│   ├── app/
+│   │   ├── page.tsx                 # Landing page (marketing)
+│   │   ├── layout.tsx               # Root layout (fonts, metadata)
+│   │   ├── login/page.tsx           # Auth: email + GitHub + Google
+│   │   ├── signup/page.tsx          # Auth + Stripe checkout flow
+│   │   ├── api/                     # 16 API routes
+│   │   │   ├── auth/                # NextAuth handler
+│   │   │   ├── stripe/              # Checkout + webhook
+│   │   │   ├── entries/             # CRUD + pagination + filters
+│   │   │   ├── sync/               # Bulk upsert (CLI sync)
+│   │   │   ├── summary/            # Aggregated stats + ROI
+│   │   │   ├── search/             # Full-text search
+│   │   │   ├── orgs/               # Org + members + invites
+│   │   │   └── integrations/       # 5 integration stubs
+│   │   └── dashboard/              # 9 authenticated pages
+│   │       ├── page.tsx            # Overview (feed + heatmap)
+│   │       ├── team/               # Manager view (charts)
+│   │       ├── projects/           # Project grid
+│   │       ├── roi/                # ROI metrics + Recharts
+│   │       ├── integrations/       # Connect/disconnect tools
+│   │       └── settings/           # Profile, billing, team mgmt
+│   ├── components/
+│   │   ├── landing/                # 12 marketing components
+│   │   ├── dashboard/              # 8 dashboard components
+│   │   └── ui/                     # 5 shared UI primitives
+│   ├── lib/                        # Core libraries
+│   │   ├── auth.ts                 # NextAuth config (DrizzleAdapter)
+│   │   ├── stripe.ts               # Stripe helpers
+│   │   ├── api-auth.ts             # API key + session auth
+│   │   ├── utils.ts                # Utility functions
+│   │   └── integrations/           # 6 integration modules
+│   ├── hooks/                      # 3 data hooks
+│   ├── types/                      # TypeScript types
+│   └── middleware.ts               # Route protection
+├── drizzle.config.ts               # Drizzle Kit config
+├── tailwind.config.ts              # Design system
+└── package.json
+```
+
+**86 files total.** TypeScript strict mode, zero type errors.
+
+---
+
+## Tech Stack
+
+| Layer     | Technology                                                                          |
+| --------- | ----------------------------------------------------------------------------------- |
+| Framework | Next.js 14 (App Router)                                                             |
+| Language  | TypeScript (strict)                                                                 |
+| Styling   | Tailwind CSS + CSS variables                                                        |
+| Database  | PostgreSQL 16 via Drizzle ORM (shared `basement_starter` DB, `bs_` prefixed tables) |
+| Auth      | NextAuth.js (GitHub, Google, email magic link)                                      |
+| Payments  | Stripe (Checkout, Webhooks, Customer Portal)                                        |
+| Charts    | Recharts                                                                            |
+| Local dev | Docker Compose                                                                      |
+
+---
+
+## Design System
+
+The visual identity is **warm, editorial, premium** -- not the typical dark dev-tool aesthetic.
+
+### Colors
+
+| Token         | Hex       | Usage                   |
+| ------------- | --------- | ----------------------- |
+| `cream`       | `#FAF8F4` | Primary background      |
+| `warm-white`  | `#FFFDF9` | Card backgrounds        |
+| `ink`         | `#1A1714` | Primary text            |
+| `ink-soft`    | `#4A453D` | Secondary text          |
+| `ink-muted`   | `#8A8379` | Tertiary text, labels   |
+| `accent`      | `#C4653A` | Terracotta orange, CTAs |
+| `accent-soft` | `#E8956A` | Hover states            |
+| `accent-bg`   | `#FFF3ED` | Accent backgrounds      |
+| `border`      | `#E8E4DE` | Card borders            |
+| `sage`        | `#6B7E6B` | Success, dev indicators |
+| `blue`        | `#4A6FA5` | Info, links             |
+
+### Typography
+
+- **Headings:** Newsreader (serif), weight 400, letter-spacing -0.025em
+- **Body:** DM Sans (sans-serif), weight 300 body / 500 labels
+- **Code:** SF Mono / Fira Code (monospace)
+
+### Animations
+
+- Word-by-word blur reveal (hero headline)
+- Terminal typing sequence with cursor blink
+- Scroll-triggered reveal (opacity + translateY)
+- Animated counters (eased count-up)
+- Tool chip stagger reveal
+- Divider accent wipe
+- Ambient glow orb drift
+- Card hover transitions
+- Nav scroll blur transition
+
+---
+
+## Landing Page
+
+The landing page at `/` is a single-page marketing site with 12 sections:
+
+1. **Navbar** -- Fixed, blur-on-scroll, logo + links + CTA
+2. **Hero** -- Glow orbs, word-by-word blur reveal headline, badge, dual CTAs
+3. **Terminal Demo** -- Typing animation showing `npx basestream init` flow
+4. **Problem Section** -- "Sessions vanish", "Tokens != outcomes", "Status is manual"
+5. **Divider** -- Accent wipe on scroll
+6. **How It Works** -- 3 numbered steps with hover accent lines
+7. **Divider**
+8. **Two Views** -- Developer journal + Manager dashboard mockups with animated counters
+9. **Integrations** -- Tool chips with stagger animation (6 active, 3 coming soon)
+10. **Pricing** -- 3-tier (Free / $12 Team / Custom Enterprise)
+11. **CTA** -- Final conversion with accent glow
+12. **Footer** -- Copyright + links
+
+---
+
+## Authentication
+
+Three providers via NextAuth.js:
+
+- **GitHub OAuth** -- `GITHUB_CLIENT_ID` + `GITHUB_CLIENT_SECRET`
+- **Google OAuth** -- `GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET`
+- **Email magic link** -- Sends sign-in link to email
+
+Session includes `user.id` and `user.plan` via callback augmentation.
+
+Middleware at `src/middleware.ts` protects all `/dashboard/*` routes.
+
+---
+
+## Stripe Integration
+
+### Flow
+
+1. User clicks "Get early access" on Team pricing -> `/signup?plan=team`
+2. After auth, redirects to `GET /api/stripe/checkout` -> Stripe Checkout
+3. Stripe webhook (`POST /api/stripe/webhook`) handles:
+   - `checkout.session.completed` -- Upgrade user to TEAM plan
+   - `customer.subscription.updated` -- Update billing period
+   - `customer.subscription.deleted` -- Downgrade to FREE
+
+### Plans
+
+| Plan       | Price       | Features                                              |
+| ---------- | ----------- | ----------------------------------------------------- |
+| Personal   | Free        | Auto-logging, personal dashboard, CLI, weekly digest  |
+| Team       | $12/user/mo | Team dashboard, privacy controls, GitHub, ROI metrics |
+| Enterprise | Custom      | SSO/SAML, SOC 2, self-hosted, RBAC, audit logs        |
+
+---
+
+## API Routes
+
+### Data Ingestion
+
+| Method | Route          | Auth    | Description                            |
+| ------ | -------------- | ------- | -------------------------------------- |
+| `POST` | `/api/entries` | API key | Create single work entry               |
+| `POST` | `/api/sync`    | API key | Bulk upsert (idempotent via sessionId) |
+
+### Data Retrieval
+
+| Method   | Route               | Auth            | Description                            |
+| -------- | ------------------- | --------------- | -------------------------------------- |
+| `GET`    | `/api/entries`      | Session/API key | List entries (paginated, filtered)     |
+| `GET`    | `/api/entries/[id]` | Session         | Get single entry                       |
+| `PATCH`  | `/api/entries/[id]` | Session         | Update entry                           |
+| `DELETE` | `/api/entries/[id]` | Session         | Delete entry                           |
+| `GET`    | `/api/summary`      | Session         | Aggregated stats (optional `type=roi`) |
+| `GET`    | `/api/search?q=`    | Session         | Full-text search on summary/why        |
+
+### Organization
+
+| Method            | Route                       | Auth               | Description               |
+| ----------------- | --------------------------- | ------------------ | ------------------------- |
+| `GET/POST`        | `/api/orgs`                 | Session            | List/create organizations |
+| `GET/POST`        | `/api/orgs/[orgId]/members` | Session (Manager+) | List/add members          |
+| `GET/POST/DELETE` | `/api/orgs/[orgId]/invites` | Session (Admin)    | Manage invites            |
+
+### Integrations
+
+| Method            | Route                               | Auth                 | Description           |
+| ----------------- | ----------------------------------- | -------------------- | --------------------- |
+| `GET/POST/DELETE` | `/api/integrations/github`          | Session + org member | GitHub integration    |
+| `GET/POST/DELETE` | `/api/integrations/hubspot`         | Session + org member | HubSpot integration   |
+| `GET/POST/DELETE` | `/api/integrations/jira`            | Session + org member | Jira integration      |
+| `GET/POST/DELETE` | `/api/integrations/google-calendar` | Session + org member | Google Calendar       |
+| `GET/POST/DELETE` | `/api/integrations/fireflies`       | Session + org member | Fireflies integration |
+
+All integration routes verify org membership. DELETE requires ADMIN role.
+
+---
+
+## Dashboard Pages
+
+All pages use the warm cream aesthetic with shared components.
+
+| Page         | Path                          | Description                                                  |
+| ------------ | ----------------------------- | ------------------------------------------------------------ |
+| Overview     | `/dashboard`                  | Personal feed + activity heatmap + quick stats               |
+| Team         | `/dashboard/team`             | Manager view: stacked bar chart, per-person activity, digest |
+| Projects     | `/dashboard/projects`         | Project grid with category breakdown bars                    |
+| ROI          | `/dashboard/roi`              | Snapshot metrics + bar/pie/line Recharts                     |
+| Integrations | `/dashboard/integrations`     | Connect/disconnect tool integrations                         |
+| Settings     | `/dashboard/settings`         | Profile, API keys, notification prefs                        |
+| Billing      | `/dashboard/settings/billing` | Plan management, Stripe portal                               |
+| Team Mgmt    | `/dashboard/settings/team`    | Members, roles, invites                                      |
+
+---
+
+## Database Schema
+
+10 models across auth, work tracking, organizations, and integrations:
+
+- **User** -- Auth + Stripe billing fields + plan
+- **Account/Session/VerificationToken** -- NextAuth adapter tables
+- **Org** -- Organization with slug
+- **OrgMember** -- User-org junction with role (ADMIN/MANAGER/DEVELOPER)
+- **OrgInvite** -- Email invitations with expiry
+- **WorkEntry** -- Core data: summary, category, why, outcome, git context, AI metadata
+- **ApiKey** -- `bs_`-prefixed keys for CLI auth
+- **Integration** -- Per-org tool connections
+
+### Seed Data
+
+Run `npx prisma db seed` to populate:
+
+- **Acme Engineering** org with 3 team members
+- **Sarah Chen** (Manager), **James Rodriguez** (Developer), **Priya Patel** (Developer)
+- **~50 work entries** across 5 projects over 2 weeks
+- Realistic summaries, PR URLs, branch names, session durations
+
+---
+
+## Claude Code Integration
+
+The core product mechanic: `src/lib/integrations/claude-code-rules.ts` exports a CLAUDE.md template that instructs Claude Code to silently log structured work entries to `~/.basestream/buffer/` after every meaningful task.
+
+Each entry captures:
+
+- Summary, category, business context (why)
+- Git context (repo, branch, files changed)
+- Outcome and complexity
+- AI metadata (model, tool version, session duration, turns)
+
+The CLI syncs buffered entries to the API via `POST /api/sync`.
+
+---
+
+## Environment Variables
+
+```bash
+# Database (shared with packages/api — same Postgres instance)
+DATABASE_URL=postgresql://postgres:postgres@localhost:5434/basement_starter
+
+# Skip Stripe for local dev
+SKIP_PAYMENT=true
+
+# Auth
+NEXTAUTH_URL=http://localhost:3000
+NEXTAUTH_SECRET=           # openssl rand -base64 32
+
+# OAuth
+GITHUB_CLIENT_ID=
+GITHUB_CLIENT_SECRET=
+GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_SECRET=
+
+# Stripe
+STRIPE_SECRET_KEY=
+STRIPE_PUBLISHABLE_KEY=
+STRIPE_WEBHOOK_SECRET=
+STRIPE_TEAM_PRICE_ID=
+
+# Integrations (optional)
+HUBSPOT_CLIENT_ID=
+HUBSPOT_CLIENT_SECRET=
+JIRA_CLIENT_ID=
+JIRA_CLIENT_SECRET=
+GOOGLE_CALENDAR_CLIENT_ID=
+GOOGLE_CALENDAR_CLIENT_SECRET=
+FIREFLIES_API_KEY=
+```
+
+---
+
+## Scripts
+
+```bash
+npm run dev              # Start dev server (port 3000)
+npm run build            # Production build
+npm run start            # Start production server
+npm run db:generate      # Generate SQL migration from schema
+npm run db:push          # Push schema to database
+npm run db:seed          # Seed demo data (npx tsx src/db/seed.ts)
+npx drizzle-kit studio   # Visual database browser
+npx tsc --noEmit         # Type check
+```
+
+---
+
+## Verification Status
+
+| Check                              | Status                                                 |
+| ---------------------------------- | ------------------------------------------------------ |
+| TypeScript strict (`tsc --noEmit`) | 0 errors                                               |
+| Next.js build (`next build`)       | All 26 pages generated                                 |
+| Landing page sections              | All 12 implemented                                     |
+| Dashboard pages                    | All 9 implemented                                      |
+| API routes                         | All 16 implemented                                     |
+| Shared components used             | All 8 dashboard + 5 UI components wired in             |
+| Auth flow                          | NextAuth + DrizzleAdapter + middleware + 3 providers   |
+| Stripe flow                        | Checkout + webhook + portal + SKIP_PAYMENT bypass      |
+| Drizzle schema                     | 10 tables (bs\_ prefixed), 7 enums, all indexes        |
+| Seed data                          | 3 users, 44 entries, 1 org                             |
+| Monorepo integration               | `packages/basestream/`, shared Postgres on port 5434   |
+| E2E API tested                     | POST/GET entries, bulk sync (idempotent), API key auth |
+| Design system                      | Colors, fonts, animations all matching spec            |
+| Mobile responsive                  | Sidebar collapse, grid stack, nav hide                 |
+| Branding                           | "Basestream" + "A Sublevel product" throughout         |

package/bin/basestream.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import("../dist/cli/index.js");

package/dist/cli/commands/hook-stop.d.ts

@@ -0,0 +1 @@
+export declare function hookStop(): Promise<void>;

package/dist/cli/commands/hook-stop.js

@@ -0,0 +1,247 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import { BUFFER_DIR, SESSION_DIR, ensureDirs, readConfig } from "../config.js";
+function parseTranscriptLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function extractGitInfo(cwd) {
+    const result = {};
+    try {
+        result.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch { }
+    try {
+        result.repo = execSync("git remote get-url origin", {
+            cwd,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch { }
+    result.projectName = path.basename(cwd);
+    return result;
+}
+function readSessionAccumulator(sessionId) {
+    const sessionFile = path.join(SESSION_DIR, `${sessionId}.json`);
+    if (!fs.existsSync(sessionFile))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(sessionFile, "utf-8"));
+        raw.filesWritten = new Set(raw.filesWritten || []);
+        raw.commitShas = new Set(raw.commitShas || []);
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function writeSessionAccumulator(acc) {
+    const sessionFile = path.join(SESSION_DIR, `${acc.sessionId}.json`);
+    const serializable = {
+        ...acc,
+        filesWritten: Array.from(acc.filesWritten),
+        commitShas: Array.from(acc.commitShas),
+    };
+    fs.writeFileSync(sessionFile, JSON.stringify(serializable, null, 2));
+}
+function analyzeTranscript(transcriptPath, acc) {
+    if (!fs.existsSync(transcriptPath))
+        return acc;
+    const content = fs.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    for (const line of lines) {
+        const msg = parseTranscriptLine(line);
+        if (!msg)
+            continue;
+        // Count assistant turns
+        if (msg.role === "assistant") {
+            acc.turns++;
+        }
+        // Track tool usage
+        if (msg.type === "tool_use" || msg.type === "tool_call") {
+            const toolName = (msg).name ||
+                msg.tool_name ||
+                "unknown";
+            acc.toolCalls.push({ tool: toolName, timestamp: msg.timestamp });
+            // Extract file paths from Write/Edit tool calls
+            if (toolName === "Write" ||
+                toolName === "Edit" ||
+                toolName === "NotebookEdit") {
+                const input = (msg).input;
+                const filePath = input?.file_path || input?.path;
+                if (filePath)
+                    acc.filesWritten.add(filePath);
+            }
+            // Extract commit SHAs from Bash tool calls
+            if (toolName === "Bash") {
+                const input = (msg).input;
+                const cmd = input?.command || "";
+                if (cmd.includes("git commit")) {
+                    // Look ahead for the result containing the SHA
+                    // We'll catch it in the tool_result handler
+                }
+            }
+        }
+        // Extract commit SHAs from tool results
+        if (msg.type === "tool_result") {
+            const resultContent = String((msg).content || "");
+            const shaMatch = resultContent.match(/\[([a-f0-9]{7,12})\]\s/);
+            if (shaMatch) {
+                acc.commitShas.add(shaMatch[1]);
+            }
+        }
+    }
+    return acc;
+}
+function categorizeWork(acc) {
+    const files = Array.from(acc.filesWritten);
+    const fileCount = files.length;
+    // Categorize based on file patterns
+    let category = "OTHER";
+    const testFiles = files.filter((f) => f.includes(".test.") || f.includes(".spec.") || f.includes("__tests__"));
+    const docFiles = files.filter((f) => f.endsWith(".md") || f.includes("/docs/"));
+    const configFiles = files.filter((f) => f.includes("Dockerfile") ||
+        f.includes(".yml") ||
+        f.includes(".yaml") ||
+        f.includes("ci"));
+    if (testFiles.length > fileCount / 2)
+        category = "TESTING";
+    else if (docFiles.length > fileCount / 2)
+        category = "DOCS";
+    else if (configFiles.length > fileCount / 2)
+        category = "DEVOPS";
+    else if (fileCount > 0)
+        category = "FEATURE";
+    // Complexity
+    let complexity = "LOW";
+    if (fileCount === 0)
+        complexity = "LOW";
+    else if (fileCount <= 2)
+        complexity = "LOW";
+    else if (fileCount <= 6)
+        complexity = "MEDIUM";
+    else
+        complexity = "HIGH";
+    return { category, complexity };
+}
+function flushToBuffer(acc) {
+    const { category, complexity } = categorizeWork(acc);
+    const now = new Date();
+    const startTime = new Date(acc.startedAt);
+    const durationMin = Math.round((now.getTime() - startTime.getTime()) / 60_000);
+    const entry = {
+        sessionId: acc.sessionId,
+        tool: "claude-code",
+        projectName: acc.projectName || path.basename(acc.cwd),
+        repo: acc.gitRepo || null,
+        branch: acc.gitBranch || null,
+        summary: buildSummary(acc, category),
+        category,
+        why: null, // Hook-based: no "why" available (CLAUDE.md rules would provide this)
+        whatChanged: Array.from(acc.filesWritten).map((f) => path.relative(acc.cwd, f) || f),
+        outcome: "IN_PROGRESS",
+        filesTouched: acc.filesWritten.size,
+        complexity,
+        toolVersion: null,
+        model: null,
+        sessionDurationMin: durationMin > 0 ? durationMin : 1,
+        turns: acc.turns,
+        prUrl: null,
+        ticketUrl: null,
+        commitShas: Array.from(acc.commitShas),
+        visibility: "TEAM",
+        bufferedAt: now.toISOString(),
+    };
+    ensureDirs();
+    const filename = `${Date.now()}-${acc.sessionId.slice(0, 8)}.json`;
+    fs.writeFileSync(path.join(BUFFER_DIR, filename), JSON.stringify(entry, null, 2));
+}
+function buildSummary(acc, category) {
+    const fileCount = acc.filesWritten.size;
+    const commitCount = acc.commitShas.size;
+    const parts = [];
+    if (category !== "OTHER") {
+        parts.push(category.toLowerCase());
+    }
+    if (fileCount > 0) {
+        parts.push(`${fileCount} file${fileCount !== 1 ? "s" : ""} modified`);
+    }
+    if (commitCount > 0) {
+        parts.push(`${commitCount} commit${commitCount !== 1 ? "s" : ""}`);
+    }
+    if (acc.projectName) {
+        parts.push(`in ${acc.projectName}`);
+    }
+    return parts.length > 0
+        ? parts.join(", ")
+        : `Claude Code session in ${acc.projectName || "unknown project"}`;
+}
+export async function hookStop() {
+    // Read hook payload from stdin
+    let payload;
+    try {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        payload = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+    }
+    catch {
+        // No valid payload — nothing to do
+        process.exit(0);
+    }
+    const { session_id, transcript_path, cwd } = payload;
+    if (!session_id)
+        process.exit(0);
+    ensureDirs();
+    // Load or create session accumulator
+    let acc = readSessionAccumulator(session_id);
+    if (!acc) {
+        const gitInfo = extractGitInfo(cwd);
+        acc = {
+            sessionId: session_id,
+            cwd,
+            startedAt: new Date().toISOString(),
+            lastUpdatedAt: new Date().toISOString(),
+            turns: 0,
+            toolCalls: [],
+            filesWritten: new Set(),
+            commitShas: new Set(),
+            gitBranch: gitInfo.branch,
+            gitRepo: gitInfo.repo,
+            projectName: gitInfo.projectName,
+        };
+    }
+    // Analyze transcript to accumulate data
+    if (transcript_path) {
+        acc = analyzeTranscript(transcript_path, acc);
+    }
+    acc.lastUpdatedAt = new Date().toISOString();
+    // Save accumulator for future Stop events in this session
+    writeSessionAccumulator(acc);
+    // Flush to buffer if we have meaningful work
+    if (acc.filesWritten.size > 0 || acc.commitShas.size > 0 || acc.turns >= 3) {
+        flushToBuffer(acc);
+        // Auto-sync if config exists
+        const config = readConfig();
+        if (config?.apiKey) {
+            try {
+                const { syncEntries } = await import("./sync.js");
+                await syncEntries(config);
+            }
+            catch {
+                // Sync failure is non-fatal — entries stay in buffer
+            }
+        }
+    }
+}

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

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/dist/cli/commands/init.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+import { ensureDirs, readConfig } from "../config.js";
+import { c, check, warn } from "../util.js";
+import { login } from "./login.js";
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const HOOK_COMMAND = "npx @basestream/cli _hook-stop";
+function detectClaudeCode() {
+    try {
+        const version = execSync("claude --version 2>/dev/null", {
+            encoding: "utf-8",
+        }).trim();
+        return version || null;
+    }
+    catch {
+        return null;
+    }
+}
+function injectClaudeCodeHook() {
+    const settingsDir = path.dirname(CLAUDE_SETTINGS_PATH);
+    fs.mkdirSync(settingsDir, { recursive: true });
+    let settings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+        try {
+            settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8"));
+        }
+        catch {
+            // Corrupted settings — start fresh
+        }
+    }
+    // Initialize hooks structure
+    if (!settings.hooks || typeof settings.hooks !== "object") {
+        settings.hooks = {};
+    }
+    const hooks = settings.hooks;
+    // Check if our hook is already installed
+    if (Array.isArray(hooks.Stop)) {
+        const existing = hooks.Stop;
+        const alreadyInstalled = existing.some((entry) => entry.hooks?.some((h) => h.command?.includes("@basestream/cli")));
+        if (alreadyInstalled) {
+            check("Claude Code hook already installed");
+            return;
+        }
+    }
+    // Add our Stop hook
+    if (!Array.isArray(hooks.Stop)) {
+        hooks.Stop = [];
+    }
+    hooks.Stop.push({
+        matcher: "*",
+        hooks: [
+            {
+                type: "command",
+                command: HOOK_COMMAND,
+                timeout: 30,
+            },
+        ],
+    });
+    fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    check("Injected tracking hook into ~/.claude/settings.json");
+}
+export async function init() {
+    console.log();
+    // 1. Detect Claude Code
+    const ccVersion = detectClaudeCode();
+    if (ccVersion) {
+        console.log(`  ${c.dim(`Detected: Claude Code ${ccVersion}`)}`);
+    }
+    else {
+        warn("Claude Code not detected — hook will activate when installed");
+    }
+    console.log();
+    // 2. Inject hook
+    injectClaudeCodeHook();
+    // 3. Create buffer directory
+    ensureDirs();
+    check(`Created ~/.basestream/buffer/`);
+    // 4. Authenticate
+    const existing = readConfig();
+    if (existing?.apiKey) {
+        check("Already authenticated");
+    }
+    else {
+        console.log();
+        await login();
+    }
+    console.log();
+    console.log(`  ${c.dim("That's it. Work normally — every session is now tracked.")}`);
+    console.log();
+}

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

@@ -0,0 +1 @@
+export declare function login(): Promise<string>;

package/dist/cli/commands/login.js

@@ -0,0 +1,75 @@
+import http from "node:http";
+import { execSync } from "node:child_process";
+import { writeConfig, readConfig } from "../config.js";
+import { c, check } from "../util.js";
+const DEFAULT_BASE_URL = "https://basestream.ai";
+function openBrowser(url) {
+    try {
+        const platform = process.platform;
+        if (platform === "darwin")
+            execSync(`open "${url}"`);
+        else if (platform === "win32")
+            execSync(`start "${url}"`);
+        else
+            execSync(`xdg-open "${url}"`);
+    }
+    catch {
+        console.log(`  ${c.dim(`Open this URL in your browser: ${url}`)}`);
+    }
+}
+export async function login() {
+    const existing = readConfig();
+    const baseUrl = existing?.baseUrl ||
+        process.env.BASESTREAM_URL ||
+        DEFAULT_BASE_URL;
+    console.log(`  ${c.dim("Opening browser for authentication...")}`);
+    // Start a temporary local server to receive the API key callback
+    const apiKey = await new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url || "/", `http://localhost`);
+            const key = url.searchParams.get("key");
+            const orgId = url.searchParams.get("orgId");
+            if (key) {
+                res.writeHead(200, { "Content-Type": "text/html" });
+                res.end(`
+          <html>
+            <body style="font-family: system-ui; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; background: #0a0a0a; color: #fafafa;">
+              <div style="text-align: center;">
+                <h1 style="color: #22c55e;">&#10003; Authenticated</h1>
+                <p style="color: #a1a1aa;">You can close this tab and return to your terminal.</p>
+              </div>
+            </body>
+          </html>
+        `);
+                server.close();
+                writeConfig({
+                    apiKey: key,
+                    baseUrl,
+                    orgId: orgId || undefined,
+                });
+                resolve(key);
+            }
+            else {
+                res.writeHead(400);
+                res.end("Missing key parameter");
+            }
+        });
+        server.listen(0, "127.0.0.1", () => {
+            const addr = server.address();
+            if (!addr || typeof addr === "string") {
+                reject(new Error("Failed to start callback server"));
+                return;
+            }
+            const callbackPort = addr.port;
+            const authUrl = `${baseUrl}/api/auth/cli?callback=http://127.0.0.1:${callbackPort}`;
+            openBrowser(authUrl);
+        });
+        // Timeout after 2 minutes
+        setTimeout(() => {
+            server.close();
+            reject(new Error("Authentication timed out"));
+        }, 120_000);
+    });
+    check("Authenticated with Basestream");
+    return apiKey;
+}

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

@@ -0,0 +1 @@
+export declare function status(): Promise<void>;

package/dist/cli/commands/status.js

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import { BUFFER_DIR, ensureDirs, readConfig } from "../config.js";
+import { c } from "../util.js";
+function groupBy(arr, fn) {
+    const result = {};
+    for (const item of arr) {
+        const key = fn(item);
+        (result[key] ??= []).push(item);
+    }
+    return result;
+}
+function formatOutcome(outcome) {
+    switch (outcome) {
+        case "COMPLETED":
+            return c.green("completed");
+        case "IN_PROGRESS":
+            return c.yellow("in progress");
+        case "BLOCKED":
+            return c.red("blocked");
+        default:
+            return c.dim(outcome.toLowerCase());
+    }
+}
+async function fetchRemoteEntries(config) {
+    try {
+        const res = await fetch(`${config.baseUrl}/api/entries?period=week&limit=100`, {
+            headers: { Authorization: `Bearer ${config.apiKey}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.entries || [];
+    }
+    catch {
+        return [];
+    }
+}
+function readLocalEntries() {
+    ensureDirs();
+    const files = fs
+        .readdirSync(BUFFER_DIR)
+        .filter((f) => f.endsWith(".json"));
+    const entries = [];
+    for (const file of files) {
+        try {
+            entries.push(JSON.parse(fs.readFileSync(path.join(BUFFER_DIR, file), "utf-8")));
+        }
+        catch { }
+    }
+    return entries;
+}
+export async function status() {
+    const config = readConfig();
+    // Combine local + remote entries
+    const entries = readLocalEntries();
+    if (config?.apiKey) {
+        const remote = await fetchRemoteEntries(config);
+        // Merge, dedup by sessionId
+        const seen = new Set(entries.map((e) => e.sessionId).filter(Boolean));
+        for (const re of remote) {
+            if (!re.sessionId || !seen.has(re.sessionId)) {
+                entries.push(re);
+            }
+        }
+    }
+    if (entries.length === 0) {
+        console.log();
+        console.log(`  ${c.dim("No sessions logged this week.")}`);
+        console.log(`  ${c.dim("Start using Claude Code — entries will appear here.")}`);
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(`  ${c.yellow(`This week — ${entries.length} sessions logged`)}`);
+    console.log();
+    // Group by project
+    const byProject = groupBy(entries, (e) => e.projectName || "unknown");
+    for (const [project, projectEntries] of Object.entries(byProject)) {
+        const commits = projectEntries.reduce((sum, e) => sum + (e.commitShas?.length || 0), 0);
+        const latestOutcome = projectEntries[0]?.outcome || "IN_PROGRESS";
+        const outcomeStr = formatOutcome(latestOutcome);
+        const parts = [`${projectEntries.length} sessions`];
+        if (commits > 0) {
+            parts.push(`${commits} commit${commits !== 1 ? "s" : ""}`);
+        }
+        parts.push(outcomeStr);
+        console.log(`  ${c.bold(project)} ${c.dim(parts.join(" · "))}`);
+    }
+    // Show pending sync count
+    const localOnly = readLocalEntries();
+    if (localOnly.length > 0) {
+        console.log();
+        console.log(`  ${c.dim(`${localOnly.length} entries pending sync`)}`);
+    }
+    console.log();
+}

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

@@ -0,0 +1,7 @@
+import { type BasestreamConfig } from "../config.js";
+export declare function syncEntries(config?: BasestreamConfig): Promise<{
+    synced: number;
+    created: number;
+    updated: number;
+} | undefined>;
+export declare function sync(): Promise<void>;

package/dist/cli/commands/sync.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { BUFFER_DIR, ensureDirs, readConfig } from "../config.js";
+import { c, check, fail } from "../util.js";
+export async function syncEntries(config) {
+    const cfg = config || readConfig();
+    if (!cfg?.apiKey) {
+        fail("Not authenticated. Run: basestream login");
+        process.exit(1);
+    }
+    ensureDirs();
+    const files = fs
+        .readdirSync(BUFFER_DIR)
+        .filter((f) => f.endsWith(".json"))
+        .sort();
+    if (files.length === 0)
+        return;
+    const entries = [];
+    const successFiles = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(BUFFER_DIR, file), "utf-8");
+            const entry = JSON.parse(raw);
+            entries.push(entry);
+            successFiles.push(file);
+        }
+        catch {
+            // Skip corrupt files
+        }
+    }
+    if (entries.length === 0)
+        return;
+    const res = await fetch(`${cfg.baseUrl}/api/sync`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`,
+        },
+        body: JSON.stringify({ entries }),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Sync failed (${res.status}): ${body}`);
+    }
+    const result = (await res.json());
+    // Clean up synced files
+    for (const file of successFiles) {
+        fs.unlinkSync(path.join(BUFFER_DIR, file));
+    }
+    return result;
+}
+export async function sync() {
+    const cfg = readConfig();
+    if (!cfg?.apiKey) {
+        fail("Not authenticated. Run: basestream login");
+        process.exit(1);
+    }
+    ensureDirs();
+    const files = fs
+        .readdirSync(BUFFER_DIR)
+        .filter((f) => f.endsWith(".json"));
+    if (files.length === 0) {
+        console.log(`  ${c.dim("No entries to sync.")}`);
+        return;
+    }
+    console.log(`  ${c.dim(`Syncing ${files.length} entries...`)}`);
+    try {
+        const result = await syncEntries(cfg);
+        if (result) {
+            check(`Synced ${result.synced} entries (${result.created} new, ${result.updated} updated)`);
+        }
+    }
+    catch (err) {
+        fail(`Sync failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,12 @@
+export declare const BASESTREAM_DIR: string;
+export declare const BUFFER_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare const SESSION_DIR: string;
+export interface BasestreamConfig {
+    apiKey: string;
+    baseUrl: string;
+    orgId?: string;
+}
+export declare function ensureDirs(): void;
+export declare function readConfig(): BasestreamConfig | null;
+export declare function writeConfig(config: BasestreamConfig): void;

package/dist/cli/config.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+export const BASESTREAM_DIR = path.join(os.homedir(), ".basestream");
+export const BUFFER_DIR = path.join(BASESTREAM_DIR, "buffer");
+export const CONFIG_FILE = path.join(BASESTREAM_DIR, "config.json");
+export const SESSION_DIR = path.join(BASESTREAM_DIR, "sessions");
+export function ensureDirs() {
+    for (const dir of [BASESTREAM_DIR, BUFFER_DIR, SESSION_DIR]) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function readConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return null;
+    try {
+        const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+        // BASESTREAM_URL env var always overrides stored baseUrl (useful for local testing)
+        if (process.env.BASESTREAM_URL) {
+            config.baseUrl = process.env.BASESTREAM_URL;
+        }
+        return config;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeConfig(config) {
+    ensureDirs();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { init } from "./commands/init.js";
+import { status } from "./commands/status.js";
+import { sync } from "./commands/sync.js";
+import { hookStop } from "./commands/hook-stop.js";
+import { login } from "./commands/login.js";
+const HELP = `
+basestream — AI work intelligence for teams
+
+Usage:
+  basestream init          Detect AI tools, inject hooks, authenticate
+  basestream login         Authenticate with your Basestream account
+  basestream status        Show this week's logged sessions
+  basestream sync          Manually sync buffered entries to Basestream
+  basestream _hook-stop    (internal) Claude Code Stop hook handler
+
+Options:
+  --help, -h               Show this help message
+  --version, -v            Show version
+`;
+async function main() {
+    const command = process.argv[2];
+    if (!command || command === "--help" || command === "-h") {
+        console.log(HELP.trim());
+        process.exit(0);
+    }
+    if (command === "--version" || command === "-v") {
+        const pkg = await import("../../package.json", { with: { type: "json" } });
+        console.log(pkg.default.version);
+        process.exit(0);
+    }
+    switch (command) {
+        case "init":
+            await init();
+            break;
+        case "login":
+            await login();
+            break;
+        case "status":
+            await status();
+            break;
+        case "sync":
+            await sync();
+            break;
+        case "_hook-stop":
+            await hookStop();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.log(HELP.trim());
+            process.exit(1);
+    }
+}
+main().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+});

package/dist/cli/util.d.ts

@@ -0,0 +1,11 @@
+export declare const c: {
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    cyan: (s: string) => string;
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+};
+export declare function check(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function fail(msg: string): void;

package/dist/cli/util.js

@@ -0,0 +1,18 @@
+// Terminal color helpers (no dependencies)
+export const c = {
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+};
+export function check(msg) {
+    console.log(`  ${c.green("✓")} ${c.green(msg)}`);
+}
+export function warn(msg) {
+    console.log(`  ${c.yellow("!")} ${c.yellow(msg)}`);
+}
+export function fail(msg) {
+    console.log(`  ${c.red("✗")} ${c.red(msg)}`);
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@basestream/cli",
+  "version": "0.1.0",
+  "description": "AI work intelligence for teams — automatic work tracking for Claude Code",
+  "type": "module",
+  "bin": {
+    "basestream": "./bin/basestream.js"
+  },
+  "files": [
+    "bin/",
+    "dist/cli/",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "NODE_OPTIONS='--max-old-space-size=4096' next dev",
+    "build": "next build",
+    "build:cli": "tsc -p tsconfig.cli.json",
+    "dev:cli": "tsc -p tsconfig.cli.json --watch",
+    "test:cli": "tsc -p tsconfig.cli.json && node bin/basestream.js",
+    "link:cli": "pnpm run build:cli && npm link",
+    "unlink:cli": "npm unlink -g @basestream/cli",
+    "prebuild:publish": "npm run build:cli",
+    "start": "next start",
+    "lint": "eslint .",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:push": "drizzle-kit push",
+    "db:seed": "tsx src/db/seed.ts"
+  },
+  "dependencies": {
+    "@neondatabase/serverless": "^1.0.2",
+    "@octokit/auth-app": "^8.2.0",
+    "@octokit/rest": "^22.0.1",
+    "@paralleldrive/cuid2": "^2.2.2",
+    "@stripe/stripe-js": "^3.0.0",
+    "better-auth": "^1.6.0",
+    "dotenv": "^17.4.1",
+    "drizzle-orm": "^0.45.2",
+    "next": "^16.2.2",
+    "pg": "^8.20.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "react-markdown": "^10.1.0",
+    "recharts": "^2.12.7",
+    "stripe": "^15.0.0",
+    "swr": "^2.4.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.2.2",
+    "@types/node": "^25.5.2",
+    "@types/pg": "^8.20.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@eslint/eslintrc": "^3",
+    "drizzle-kit": "^0.31.10",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.2",
+    "postcss": "^8.4.38",
+    "tailwindcss": "^4.2.2",
+    "tsx": "^4.19.0",
+    "typescript": "^5.4.5"
+  }
+}