@enspirit/bmg-js 1.0.0 → 1.0.2

package/src/lib-definitions.ts

@@ -0,0 +1,281 @@
+// Auto-generated from types.ts
+// Run 'npm run generate:lib-definitions' to regenerate
+
+export const LIB_DEFINITIONS = `
+/**
+ * Type definitions for Bmg.js relational algebra library.
+ *
+ * This file defines all types needed for type-safe relational operations:
+ * - Base types (AttrName, Tuple)
+ * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)
+ * - The Relation interface with all operators
+ * - Helper types for predicates, extensions, aggregators, etc.
+ */
+
+// ============================================================================
+// Base Types
+// ============================================================================
+
+/** Attribute name in a tuple */
+type AttrName = string
+
+/** A tuple is a record mapping attribute names to values */
+type Tuple = Record<AttrName, unknown>
+
+// ============================================================================
+// Rename Types
+// ============================================================================
+
+/** Map from old attribute names to new attribute names */
+type RenameMap<T> = { [K in keyof T]?: string };
+
+/** Transform tuple type by renaming keys according to RenameMap */
+type Renamed<T, R extends RenameMap<T>> = {
+  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];
+};
+
+// ============================================================================
+// Prefix/Suffix Types
+// ============================================================================
+
+/** Prefix all keys except those in Except */
+type Prefixed<T, P extends string, Except extends keyof T = never> = {
+  [K in keyof T as K extends Except ? K : \`\${P}\${K & string}\`]: T[K];
+};
+
+/** Suffix all keys except those in Except */
+type Suffixed<T, S extends string, Except extends keyof T = never> = {
+  [K in keyof T as K extends Except ? K : \`\${K & string}\${S}\`]: T[K];
+};
+
+// ============================================================================
+// Join Types
+// ============================================================================
+
+/** Extract common keys between two tuple types */
+type CommonKeys<L, R> = Extract<keyof L, keyof R>;
+
+/** Result of inner join: L & R with R's common keys removed */
+type Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;
+
+/** Result of left join: L & optional R attributes (common keys removed) */
+type LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;
+
+/**
+ * Typed join keys for array form: keys must exist on BOTH operands.
+ * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.
+ */
+type TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];
+
+/**
+ * Typed join keys for object form: maps left keys to right keys.
+ * Example: suppliers.join(parts, { sid: 'supplier_id' })
+ * - Left key (sid) must exist on L
+ * - Right key (supplier_id) must exist on R
+ */
+type TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };
+
+// ============================================================================
+// Wrap/Unwrap Types
+// ============================================================================
+
+/** Result of wrap: remove wrapped attrs, add nested object */
+type Wrapped<T, K extends keyof T, As extends string> =
+  Omit<T, K> & Record<As, Pick<T, K>>;
+
+/** Result of unwrap: remove object attr, spread its properties */
+type Unwrapped<T, K extends keyof T> =
+  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;
+
+/** Result of ungroup: remove relation attr, flatten its tuple type */
+type Ungrouped<T, K extends keyof T> =
+  T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;
+
+// ============================================================================
+// Aggregator Types
+// ============================================================================
+
+type AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'
+type AggregatorSpec = { op: AggregatorName, attr: AttrName }
+type AggregatorFunc = (tuples: Tuple[]) => unknown
+type Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc
+type Aggregators = Record<AttrName, Aggregator>
+
+/** Infer result type from aggregator specification */
+type AggregatorResult<A> =
+  A extends 'count' ? number :
+  A extends { op: 'count' } ? number :
+  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :
+  A extends { op: 'collect' } ? unknown[] :
+  A extends (tuples: Tuple[]) => infer R ? R :
+  unknown;
+
+/** Map aggregator definitions to their result types */
+type AggregatorResults<Aggs extends Record<string, unknown>> = {
+  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;
+};
+
+// ============================================================================
+// Predicate Types
+// ============================================================================
+
+/** Predicate function that receives a typed tuple */
+type TypedPredicateFunc<T> = (t: T) => boolean
+
+/** Predicate: either a partial tuple for equality matching, or a function */
+type TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>
+
+// Legacy predicate types (for backwards compatibility with standalone operators)
+type PredicateFunc = ((t: Tuple) => any)
+type Predicate = Tuple | PredicateFunc
+
+// ============================================================================
+// Extension Types
+// ============================================================================
+
+/** Extension function that receives a typed tuple */
+type TypedExtensionFunc<T, R> = (tuple: T) => R
+
+/** Extension definition: function returning value, or attribute name to copy */
+type TypedExtension<T, E extends Record<string, unknown>> = {
+  [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;
+}
+
+type ExtensionFunc = (tuple: Tuple) => unknown
+type Extension = Record<AttrName, ExtensionFunc | AttrName>
+
+// ============================================================================
+// Other Helper Types
+// ============================================================================
+
+interface PrefixOptions {
+  except?: AttrName[]
+}
+
+interface SuffixOptions {
+  except?: AttrName[]
+}
+
+interface AutowrapOptions {
+  separator?: string
+}
+
+type Renaming = RenamingObj | RenamingFunc
+type RenamingFunc = (attr: AttrName) => AttrName
+type RenamingObj = Record<AttrName, AttrName>
+
+type JoinKeys = AttrName[] | Record<AttrName, AttrName>
+
+type TransformFunc = (value: unknown) => unknown
+type Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>
+
+// ============================================================================
+// Relation Interface
+// ============================================================================
+
+/**
+ * Relation interface with generic type parameter for tuple type.
+ * Default parameter \`Tuple\` ensures backwards compatibility.
+ *
+ * @typeParam T - The tuple type for this relation. Defaults to \`Tuple\` (Record<string, unknown>).
+ *
+ * @example
+ * // Untyped usage (backwards compatible)
+ * const r = Bmg([{ id: 1 }]);  // Relation<Tuple>
+ *
+ * @example
+ * // Typed usage with full type safety
+ * interface Person { id: number; name: string }
+ * const r = Bmg<Person>([{ id: 1, name: 'Alice' }]);
+ * r.project(['id']);  // Relation<{ id: number }>
+ */
+interface Relation<T = Tuple> {
+  // === Type-preserving operators ===
+
+  restrict(p: TypedPredicate<T>): Relation<T>
+  where(p: TypedPredicate<T>): Relation<T>
+  exclude(p: TypedPredicate<T>): Relation<T>
+
+  // === Projection operators ===
+
+  project<K extends keyof T>(attrs: K[]): Relation<Pick<T, K>>
+  allbut<K extends keyof T>(attrs: K[]): Relation<Omit<T, K>>
+
+  // === Extension operators ===
+
+  extend<E extends Record<string, unknown>>(e: TypedExtension<T, E>): Relation<T & E>
+  constants<C extends Tuple>(consts: C): Relation<T & C>
+
+  // === Rename operators ===
+
+  rename<R extends RenameMap<T>>(r: R): Relation<Renamed<T, R>>
+  prefix<P extends string, Ex extends keyof T = never>(pfx: P, options?: { except?: Ex[] }): Relation<Prefixed<T, P, Ex>>
+  suffix<S extends string, Ex extends keyof T = never>(sfx: S, options?: { except?: Ex[] }): Relation<Suffixed<T, S, Ex>>
+
+  // === Set operators (require same type) ===
+
+  union(right: RelationOperand<T>): Relation<T>
+  minus(right: RelationOperand<T>): Relation<T>
+  intersect(right: RelationOperand<T>): Relation<T>
+
+  // === Semi-join operators (preserve left type) ===
+
+  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>
+  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>
+
+  // === Join operators ===
+
+  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>
+  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>
+  cross_product<R>(right: RelationOperand<R>): Relation<T & R>
+  cross_join<R>(right: RelationOperand<R>): Relation<T & R>
+
+  // === Nesting operators ===
+
+  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>
+  group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>
+  ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>
+  wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>
+  unwrap<K extends keyof T>(attr: K): Relation<Unwrapped<T, K>>
+
+  // === Aggregation ===
+
+  summarize<By extends keyof T, Aggs extends Aggregators>(by: By[], aggs: Aggs): Relation<Pick<T, By> & AggregatorResults<Aggs>>
+
+  // === Transform ===
+
+  transform(t: Transformation): Relation<T>
+
+  // === Dynamic (loses type precision) ===
+
+  autowrap(options?: AutowrapOptions): Relation<Tuple>
+
+  // === Non-relational ===
+
+  one(): T
+  yByX<Y extends keyof T, X extends keyof T>(y: Y, x: X): Record<T[X] & PropertyKey, T[Y]>
+  toArray(): T[]
+  isEqual(right: any): boolean
+}
+
+// ============================================================================
+// Operands
+// ============================================================================
+
+type RelationOperand<T = Tuple> = Relation<T> | T[]
+
+interface OperationalOperand<T = Tuple> {
+  tuples(): Iterable<T>
+  output(tuples: T[]): RelationOperand<T>
+}
+
+// ============================================================================
+// Bmg Function Declaration
+// ============================================================================
+
+/** Create a relation from an array of tuples */
+declare function Bmg<T>(tuples: T[]): Relation<T>
+declare namespace Bmg {
+  function isRelation(op: unknown): boolean
+}
+`

package/src/types.ts

@@ -1,36 +1,118 @@
-import type {
-  RenameMap, Renamed,
-  Prefixed, Suffixed,
-  Joined, LeftJoined,
-  Wrapped, Unwrapped,
-  AggregatorResults
-} from './utility-types';
+/**
+ * Type definitions for Bmg.js relational algebra library.
+ *
+ * This file defines all types needed for type-safe relational operations:
+ * - Base types (AttrName, Tuple)
+ * - Utility types for transformations (Renamed, Prefixed, Joined, etc.)
+ * - The Relation interface with all operators
+ * - Helper types for predicates, extensions, aggregators, etc.
+ */
+
+// ============================================================================
+// Base Types
+// ============================================================================
+
+/** Attribute name in a tuple */
+export type AttrName = string
+
+/** A tuple is a record mapping attribute names to values */
+export type Tuple = Record<AttrName, unknown>
 
 // ============================================================================
-// Group/Ungroup Types (defined here due to Relation dependency)
+// Rename Types
 // ============================================================================
 
+/** Map from old attribute names to new attribute names */
+export type RenameMap<T> = { [K in keyof T]?: string };
+
+/** Transform tuple type by renaming keys according to RenameMap */
+export type Renamed<T, R extends RenameMap<T>> = {
+  [K in keyof T as K extends keyof R ? (R[K] extends string ? R[K] : K) : K]: T[K];
+};
+
+// ============================================================================
+// Prefix/Suffix Types
+// ============================================================================
+
+/** Prefix all keys except those in Except */
+export type Prefixed<T, P extends string, Except extends keyof T = never> = {
+  [K in keyof T as K extends Except ? K : `${P}${K & string}`]: T[K];
+};
+
+/** Suffix all keys except those in Except */
+export type Suffixed<T, S extends string, Except extends keyof T = never> = {
+  [K in keyof T as K extends Except ? K : `${K & string}${S}`]: T[K];
+};
+
+// ============================================================================
+// Join Types
+// ============================================================================
+
+/** Extract common keys between two tuple types */
+export type CommonKeys<L, R> = Extract<keyof L, keyof R>;
+
+/** Result of inner join: L & R with R's common keys removed */
+export type Joined<L, R> = L & Omit<R, CommonKeys<L, R>>;
+
+/** Result of left join: L & optional R attributes (common keys removed) */
+export type LeftJoined<L, R> = L & Partial<Omit<R, CommonKeys<L, R>>>;
+
+/**
+ * Typed join keys for array form: keys must exist on BOTH operands.
+ * Example: suppliers.join(parts, ['city']) - 'city' must be a key of both.
+ */
+export type TypedJoinKeysArray<L, R> = (keyof L & keyof R & string)[];
+
+/**
+ * Typed join keys for object form: maps left keys to right keys.
+ * Example: suppliers.join(parts, { sid: 'supplier_id' })
+ * - Left key (sid) must exist on L
+ * - Right key (supplier_id) must exist on R
+ */
+export type TypedJoinKeysObject<L, R> = { [K in keyof L & string]?: keyof R & string };
+
+// ============================================================================
+// Wrap/Unwrap Types
+// ============================================================================
+
+/** Result of wrap: remove wrapped attrs, add nested object */
+export type Wrapped<T, K extends keyof T, As extends string> =
+  Omit<T, K> & Record<As, Pick<T, K>>;
+
+/** Result of unwrap: remove object attr, spread its properties */
+export type Unwrapped<T, K extends keyof T> =
+  T[K] extends Record<string, unknown> ? Omit<T, K> & T[K] : Omit<T, K>;
+
 /** Result of ungroup: remove relation attr, flatten its tuple type */
 export type Ungrouped<T, K extends keyof T> =
   T[K] extends Relation<infer N> ? Omit<T, K> & N : Omit<T, K>;
 
-export type AttrName = string
-export type Tuple = Record<AttrName, unknown>
+// ============================================================================
+// Aggregator Types
+// ============================================================================
 
-export interface PrefixOptions {
-  except?: AttrName[]
-}
+export type AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'
+export type AggregatorSpec = { op: AggregatorName, attr: AttrName }
+export type AggregatorFunc = (tuples: Tuple[]) => unknown
+export type Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc
+export type Aggregators = Record<AttrName, Aggregator>
 
-export interface SuffixOptions {
-  except?: AttrName[]
-}
+/** Infer result type from aggregator specification */
+export type AggregatorResult<A> =
+  A extends 'count' ? number :
+  A extends { op: 'count' } ? number :
+  A extends { op: 'sum' | 'avg' | 'min' | 'max' } ? number | null :
+  A extends { op: 'collect' } ? unknown[] :
+  A extends (tuples: Tuple[]) => infer R ? R :
+  unknown;
 
-export interface AutowrapOptions {
-  separator?: string
-}
+/** Map aggregator definitions to their result types */
+export type AggregatorResults<Aggs extends Record<string, unknown>> = {
+  [K in keyof Aggs]: AggregatorResult<Aggs[K]>;
+};
 
 // ============================================================================
-// Typed Predicates
+// Predicate Types
 // ============================================================================
 
 /** Predicate function that receives a typed tuple */
@@ -39,8 +121,12 @@ export type TypedPredicateFunc<T> = (t: T) => boolean
 /** Predicate: either a partial tuple for equality matching, or a function */
 export type TypedPredicate<T> = Partial<T> | TypedPredicateFunc<T>
 
+// Legacy predicate types (for backwards compatibility with standalone operators)
+export type PredicateFunc = ((t: Tuple) => any)
+export type Predicate = Tuple | PredicateFunc
+
 // ============================================================================
-// Typed Extensions
+// Extension Types
 // ============================================================================
 
 /** Extension function that receives a typed tuple */
@@ -51,8 +137,36 @@ export type TypedExtension<T, E extends Record<string, unknown>> = {
   [K in keyof E]: TypedExtensionFunc<T, E[K]> | keyof T;
 }
 
+export type ExtensionFunc = (tuple: Tuple) => unknown
+export type Extension = Record<AttrName, ExtensionFunc | AttrName>
+
 // ============================================================================
-// Generic Relation Interface
+// Other Helper Types
+// ============================================================================
+
+export interface PrefixOptions {
+  except?: AttrName[]
+}
+
+export interface SuffixOptions {
+  except?: AttrName[]
+}
+
+export interface AutowrapOptions {
+  separator?: string
+}
+
+export type Renaming = RenamingObj | RenamingFunc
+export type RenamingFunc = (attr: AttrName) => AttrName
+export type RenamingObj = Record<AttrName, AttrName>
+
+export type JoinKeys = AttrName[] | Record<AttrName, AttrName>
+
+export type TransformFunc = (value: unknown) => unknown
+export type Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>
+
+// ============================================================================
+// Relation Interface
 // ============================================================================
 
 /**
@@ -102,19 +216,19 @@ export interface Relation<T = Tuple> {
 
   // === Semi-join operators (preserve left type) ===
 
-  matching<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<T>
-  not_matching<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<T>
+  matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>
+  not_matching<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T>
 
   // === Join operators ===
 
-  join<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<Joined<T, R>>
-  left_join<R>(right: RelationOperand<R>, keys?: JoinKeys): Relation<LeftJoined<T, R>>
+  join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<Joined<T, R>>
+  left_join<R>(right: RelationOperand<R>, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<LeftJoined<T, R>>
   cross_product<R>(right: RelationOperand<R>): Relation<T & R>
   cross_join<R>(right: RelationOperand<R>): Relation<T & R>
 
   // === Nesting operators ===
 
-  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: JoinKeys): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>
+  image<R, As extends string>(right: RelationOperand<R>, as: As, keys?: TypedJoinKeysArray<T, R> | TypedJoinKeysObject<T, R>): Relation<T & Record<As, Relation<Omit<R, keyof T & keyof R>>>>
   group<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Omit<T, K> & Record<As, Relation<Pick<T, K>>>>
   ungroup<K extends keyof T>(attr: K): Relation<Ungrouped<T, K>>
   wrap<K extends keyof T, As extends string>(attrs: K[], as: As): Relation<Wrapped<T, K, As>>
@@ -141,7 +255,7 @@ export interface Relation<T = Tuple> {
 }
 
 // ============================================================================
-// Operands and Helpers
+// Operands
 // ============================================================================
 
 export type RelationOperand<T = Tuple> = Relation<T> | T[]
@@ -150,29 +264,3 @@ export interface OperationalOperand<T = Tuple> {
   tuples(): Iterable<T>
   output(tuples: T[]): RelationOperand<T>
 }
-
-// Legacy predicate types (for backwards compatibility with standalone operators)
-export type PredicateFunc = ((t: Tuple) => any)
-export type Predicate = Tuple | PredicateFunc
-
-export type Renaming = RenamingObj | RenamingFunc
-export type RenamingFunc = (attr: AttrName) => AttrName
-export type RenamingObj = Record<AttrName, AttrName>
-
-export type ExtensionFunc = (tuple: Tuple) => unknown
-export type Extension = Record<AttrName, ExtensionFunc | AttrName>
-
-export type JoinKeys = AttrName[] | Record<AttrName, AttrName>
-
-export type AggregatorName = 'count' | 'sum' | 'min' | 'max' | 'avg' | 'collect'
-export type AggregatorSpec = { op: AggregatorName, attr: AttrName }
-export type AggregatorFunc = (tuples: Tuple[]) => unknown
-export type Aggregator = AggregatorName | AggregatorSpec | AggregatorFunc
-export type Aggregators = Record<AttrName, Aggregator>
-
-export type TransformFunc = (value: unknown) => unknown
-export type Transformation = TransformFunc | TransformFunc[] | Record<AttrName, TransformFunc | TransformFunc[]>
-
-// Re-export utility types for convenience
-export type { RenameMap, Renamed, Prefixed, Suffixed, Joined, LeftJoined, Wrapped, Unwrapped } from './utility-types';
-// Ungrouped is defined in this file (not utility-types) due to Relation dependency

package/.claude/safe-setup/.env.example

@@ -1,3 +0,0 @@
-# Git configuration (used for commits inside the container)
-GIT_USER_NAME=Your Name
-GIT_USER_EMAIL=your.email@example.com

package/.claude/safe-setup/Dockerfile.claude

@@ -1,36 +0,0 @@
-FROM alpine:latest
-
-# Install packages: base tools, node, ruby, postgresql client
-RUN apk update && apk add --no-cache \
-    bash \
-    curl \
-    git \
-    build-base \
-    nodejs \
-    npm \
-    vim \
-    sudo
-
-# Create non-root user with sudo access
-RUN addgroup -S bmg && adduser -S bmg -G bmg \
-    && echo "bmg ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
-
-# Install Claude Code CLI globally
-RUN npm install -g @anthropic-ai/claude-code
-
-# Set up working directory
-WORKDIR /workspace
-
-# Copy and set up entrypoint
-COPY entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
-
-# Create .claude directory for history persistence
-RUN mkdir -p /home/bmg/.claude && chown -R bmg:bmg /home/bmg/.claude
-
-# Switch to non-root user
-USER bmg
-
-# Use entrypoint to configure git and run command
-ENTRYPOINT ["/entrypoint.sh"]
-CMD ["bash"]

package/.claude/safe-setup/HACKING.md

@@ -1,63 +0,0 @@
-# Hacking on Bmg with Claude Code
-
-This Docker setup provides a sandboxed environment with all tools needed to hack on Bmg:
-- Node.js
-- Claude Code CLI
-
-## Prerequisites
-
-1. Docker and Docker Compose installed
-2. A Claude Code account
-
-## Getting Started
-
-```bash
-cd .claude/safe-setup
-
-# Create your .env file from template
-cp .env.example .env
-
-# Edit .env to set your git identity
-# GIT_USER_NAME=Your Name
-# GIT_USER_EMAIL=your.email@example.com
-
-# Build and start containers
-make up
-
-# Enter the dev environment
-make shell
-```
-
-## Persistent Data
-
-- **Claude history**: Stored in a named Docker volume (`claude-history`) that persists across container restarts
-- **Git configuration**: Automatically set from `GIT_USER_NAME` and `GIT_USER_EMAIL` environment variables
-
-## Inside the Container
-
-You're now user `bmg` in `/workspace` (the Bmg project root).
-
-```bash
-# Install project dependencies
-npm install
-
-# Run tests
-npm run test
-
-# Use Claude Code
-claude
-```
-
-PostgreSQL is pre-configured via environment variables. Just run `psql` to connect.
-
-## Commands
-
-| Command | Description |
-|---------|-------------|
-| `make up` | Build and start containers |
-| `make down` | Stop containers |
-| `make shell` | Enter dev container |
-| `make restart` | Restart everything |
-| `make logs` | Follow container logs |
-| `make status` | Show container status |
-| `make clean` | Remove containers and images |

package/.claude/safe-setup/Makefile

@@ -1,22 +0,0 @@
-.PHONY: up down shell restart clean logs status
-
-up:
-	docker compose up -d --build
-	@echo "Containers started. Use 'make shell' to access dev environment"
-
-down:
-	docker compose down
-
-shell:
-	docker compose exec dev bash
-
-restart: down up
-
-clean: down
-	docker compose down --rmi all --volumes
-
-logs:
-	docker compose logs -f
-
-status:
-	@docker compose ps

package/.claude/safe-setup/docker-compose.yml

@@ -1,18 +0,0 @@
-services:
-
-  dev:
-    build:
-      context: .
-      dockerfile: Dockerfile.claude
-    container_name: claude
-    volumes:
-      - ../..:/workspace
-      - claude-history:/home/bmg/.claude
-    environment:
-      - GIT_USER_NAME=${GIT_USER_NAME:-}
-      - GIT_USER_EMAIL=${GIT_USER_EMAIL:-}
-    stdin_open: true
-    tty: true
-
-volumes:
-  claude-history: