@timmeck/marketing-brain 0.2.0

package/src/db/repositories/post.repository.ts

@@ -0,0 +1,123 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { Post, PostCreate } from '../../types/post.types.js';
+import { sha256 } from '../../utils/hash.js';
+
+export class PostRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO posts (campaign_id, platform, content, format, hashtags, url, published_at, fingerprint, status)
+        VALUES (@campaign_id, @platform, @content, @format, @hashtags, @url, @published_at, @fingerprint, @status)
+      `),
+      getById: db.prepare('SELECT * FROM posts WHERE id = ?'),
+      getByFingerprint: db.prepare('SELECT * FROM posts WHERE fingerprint = ?'),
+      listAll: db.prepare('SELECT * FROM posts ORDER BY created_at DESC LIMIT ?'),
+      listByPlatform: db.prepare('SELECT * FROM posts WHERE platform = ? ORDER BY created_at DESC LIMIT ?'),
+      listByCampaign: db.prepare('SELECT * FROM posts WHERE campaign_id = ? ORDER BY created_at DESC LIMIT ?'),
+      listPublished: db.prepare(`SELECT * FROM posts WHERE status = 'published' ORDER BY published_at DESC LIMIT ?`),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM posts'),
+      countByPlatform: db.prepare('SELECT platform, COUNT(*) as count FROM posts GROUP BY platform'),
+      countByStatus: db.prepare('SELECT status, COUNT(*) as count FROM posts GROUP BY status'),
+      delete: db.prepare('DELETE FROM posts WHERE id = ?'),
+      search: db.prepare(`
+        SELECT p.* FROM posts p
+        JOIN posts_fts f ON f.rowid = p.id
+        WHERE posts_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `),
+      recentPublished: db.prepare(`
+        SELECT * FROM posts WHERE status = 'published' AND published_at > ? ORDER BY published_at DESC
+      `),
+    };
+  }
+
+  create(data: PostCreate): number {
+    const fingerprint = sha256(`${data.platform}:${data.content}`);
+    const result = this.stmts.create.run({
+      campaign_id: data.campaign_id ?? null,
+      platform: data.platform,
+      content: data.content,
+      format: data.format ?? 'text',
+      hashtags: data.hashtags ?? null,
+      url: data.url ?? null,
+      published_at: data.published_at ?? null,
+      fingerprint,
+      status: data.status ?? 'draft',
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): Post | undefined {
+    return this.stmts.getById.get(id) as Post | undefined;
+  }
+
+  getByFingerprint(fingerprint: string): Post | undefined {
+    return this.stmts.getByFingerprint.get(fingerprint) as Post | undefined;
+  }
+
+  listAll(limit: number = 50): Post[] {
+    return this.stmts.listAll.all(limit) as Post[];
+  }
+
+  listByPlatform(platform: string, limit: number = 50): Post[] {
+    return this.stmts.listByPlatform.all(platform, limit) as Post[];
+  }
+
+  listByCampaign(campaignId: number, limit: number = 50): Post[] {
+    return this.stmts.listByCampaign.all(campaignId, limit) as Post[];
+  }
+
+  listPublished(limit: number = 50): Post[] {
+    return this.stmts.listPublished.all(limit) as Post[];
+  }
+
+  recentPublished(sinceDate: string): Post[] {
+    return this.stmts.recentPublished.all(sinceDate) as Post[];
+  }
+
+  update(id: number, data: Partial<Post>): boolean {
+    const fields = Object.keys(data).filter(
+      (key) => key !== 'id' && key !== 'created_at' && (data as Record<string, unknown>)[key] !== undefined
+    );
+    if (fields.length === 0) return false;
+
+    const setClauses = fields.map((f) => `${f} = @${f}`).join(', ');
+    const stmt = this.db.prepare(
+      `UPDATE posts SET ${setClauses}, updated_at = datetime('now') WHERE id = @id`
+    );
+    const result = stmt.run({ ...data, id });
+    return result.changes > 0;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+
+  search(query: string, limit: number = 20): Post[] {
+    return this.stmts.search.all(query, limit) as Post[];
+  }
+
+  countAll(): number {
+    const row = this.stmts.countAll.get() as { count: number };
+    return row.count;
+  }
+
+  countByPlatform(): Record<string, number> {
+    const rows = this.stmts.countByPlatform.all() as Array<{ platform: string; count: number }>;
+    const result: Record<string, number> = {};
+    for (const row of rows) result[row.platform] = row.count;
+    return result;
+  }
+
+  countByStatus(): Record<string, number> {
+    const rows = this.stmts.countByStatus.all() as Array<{ status: string; count: number }>;
+    const result: Record<string, number> = {};
+    for (const row of rows) result[row.status] = row.count;
+    return result;
+  }
+}

package/src/db/repositories/rule.repository.ts

@@ -0,0 +1,87 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { MarketingRule, RuleCreate } from '../../types/post.types.js';
+
+export class RuleRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO marketing_rules (pattern, recommendation, confidence)
+        VALUES (@pattern, @recommendation, @confidence)
+      `),
+      getById: db.prepare('SELECT * FROM marketing_rules WHERE id = ?'),
+      listAll: db.prepare('SELECT * FROM marketing_rules ORDER BY confidence DESC'),
+      listActive: db.prepare(`SELECT * FROM marketing_rules WHERE active = 1 ORDER BY confidence DESC`),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM marketing_rules'),
+      countActive: db.prepare(`SELECT COUNT(*) as count FROM marketing_rules WHERE active = 1`),
+      delete: db.prepare('DELETE FROM marketing_rules WHERE id = ?'),
+    };
+  }
+
+  create(data: RuleCreate): number {
+    const result = this.stmts.create.run({
+      pattern: data.pattern,
+      recommendation: data.recommendation,
+      confidence: data.confidence ?? 0.5,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): MarketingRule | undefined {
+    return this.stmts.getById.get(id) as MarketingRule | undefined;
+  }
+
+  listAll(): MarketingRule[] {
+    return this.stmts.listAll.all() as MarketingRule[];
+  }
+
+  listActive(): MarketingRule[] {
+    return this.stmts.listActive.all() as MarketingRule[];
+  }
+
+  update(id: number, data: Partial<MarketingRule>): boolean {
+    const fields = Object.keys(data).filter(
+      (key) => key !== 'id' && key !== 'created_at' && (data as Record<string, unknown>)[key] !== undefined
+    );
+    if (fields.length === 0) return false;
+
+    const setClauses = fields.map((f) => `${f} = @${f}`).join(', ');
+    const stmt = this.db.prepare(
+      `UPDATE marketing_rules SET ${setClauses}, updated_at = datetime('now') WHERE id = @id`
+    );
+    const result = stmt.run({ ...data, id });
+    return result.changes > 0;
+  }
+
+  incrementTrigger(id: number, success: boolean): void {
+    const rule = this.getById(id);
+    if (!rule) return;
+    const data: Record<string, unknown> = {
+      trigger_count: rule.trigger_count + 1,
+      id,
+    };
+    if (success) data['success_count'] = rule.success_count + 1;
+
+    const stmt = this.db.prepare(
+      `UPDATE marketing_rules SET trigger_count = @trigger_count${success ? ', success_count = @success_count' : ''}, updated_at = datetime('now') WHERE id = @id`
+    );
+    stmt.run(data);
+  }
+
+  countAll(): number {
+    const row = this.stmts.countAll.get() as { count: number };
+    return row.count;
+  }
+
+  countActive(): number {
+    const row = this.stmts.countActive.get() as { count: number };
+    return row.count;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+}

package/src/db/repositories/strategy.repository.ts

@@ -0,0 +1,82 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { Strategy, StrategyCreate } from '../../types/post.types.js';
+
+export class StrategyRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO strategies (post_id, description, approach, outcome, confidence)
+        VALUES (@post_id, @description, @approach, @outcome, @confidence)
+      `),
+      getById: db.prepare('SELECT * FROM strategies WHERE id = ?'),
+      listAll: db.prepare('SELECT * FROM strategies ORDER BY confidence DESC LIMIT ?'),
+      listByPost: db.prepare('SELECT * FROM strategies WHERE post_id = ? ORDER BY confidence DESC'),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM strategies'),
+      search: db.prepare(`
+        SELECT s.* FROM strategies s
+        JOIN strategies_fts f ON f.rowid = s.id
+        WHERE strategies_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `),
+      topByConfidence: db.prepare('SELECT * FROM strategies WHERE confidence >= ? ORDER BY confidence DESC LIMIT ?'),
+      delete: db.prepare('DELETE FROM strategies WHERE id = ?'),
+    };
+  }
+
+  create(data: StrategyCreate): number {
+    const result = this.stmts.create.run({
+      post_id: data.post_id ?? null,
+      description: data.description,
+      approach: data.approach ?? null,
+      outcome: data.outcome ?? null,
+      confidence: 0.5,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): Strategy | undefined {
+    return this.stmts.getById.get(id) as Strategy | undefined;
+  }
+
+  listAll(limit: number = 50): Strategy[] {
+    return this.stmts.listAll.all(limit) as Strategy[];
+  }
+
+  listByPost(postId: number): Strategy[] {
+    return this.stmts.listByPost.all(postId) as Strategy[];
+  }
+
+  search(query: string, limit: number = 20): Strategy[] {
+    return this.stmts.search.all(query, limit) as Strategy[];
+  }
+
+  topByConfidence(minConfidence: number = 0.7, limit: number = 20): Strategy[] {
+    return this.stmts.topByConfidence.all(minConfidence, limit) as Strategy[];
+  }
+
+  update(id: number, data: Partial<Strategy>): boolean {
+    const fields = Object.keys(data).filter(
+      (key) => key !== 'id' && key !== 'created_at' && (data as Record<string, unknown>)[key] !== undefined
+    );
+    if (fields.length === 0) return false;
+
+    const setClauses = fields.map((f) => `${f} = @${f}`).join(', ');
+    const stmt = this.db.prepare(`UPDATE strategies SET ${setClauses} WHERE id = @id`);
+    const result = stmt.run({ ...data, id });
+    return result.changes > 0;
+  }
+
+  countAll(): number {
+    const row = this.stmts.countAll.get() as { count: number };
+    return row.count;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+}

package/src/db/repositories/synapse.repository.ts

@@ -0,0 +1,148 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { SynapseRecord } from '../../types/synapse.types.js';
+
+type SynapseCreate = Omit<SynapseRecord, 'id' | 'activation_count' | 'last_activated_at' | 'created_at' | 'updated_at'>;
+type SynapseUpdate = Partial<Omit<SynapseRecord, 'id' | 'created_at'>>;
+
+export class SynapseRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO synapses (source_type, source_id, target_type, target_id, synapse_type, weight, metadata)
+        VALUES (@source_type, @source_id, @target_type, @target_id, @synapse_type, @weight, @metadata)
+      `),
+      getById: db.prepare('SELECT * FROM synapses WHERE id = ?'),
+      delete: db.prepare('DELETE FROM synapses WHERE id = ?'),
+      getOutgoing: db.prepare(
+        'SELECT * FROM synapses WHERE source_type = ? AND source_id = ? ORDER BY weight DESC'
+      ),
+      getIncoming: db.prepare(
+        'SELECT * FROM synapses WHERE target_type = ? AND target_id = ? ORDER BY weight DESC'
+      ),
+      findConnected: db.prepare(`
+        SELECT * FROM synapses
+        WHERE (source_type = ? AND source_id = ?) OR (target_type = ? AND target_id = ?)
+        ORDER BY weight DESC
+      `),
+      findBySourceTarget: db.prepare(`
+        SELECT * FROM synapses
+        WHERE source_type = ? AND source_id = ? AND target_type = ? AND target_id = ? AND synapse_type = ?
+      `),
+      findInactiveSince: db.prepare(`
+        SELECT * FROM synapses WHERE last_activated_at < ?
+      `),
+      countNodes: db.prepare(`
+        SELECT COUNT(*) as count FROM (
+          SELECT source_type, source_id FROM synapses
+          UNION
+          SELECT target_type, target_id FROM synapses
+        )
+      `),
+      avgWeight: db.prepare('SELECT AVG(weight) as avg_weight FROM synapses'),
+      countByType: db.prepare('SELECT synapse_type, COUNT(*) as count FROM synapses GROUP BY synapse_type'),
+      totalCount: db.prepare('SELECT COUNT(*) as count FROM synapses'),
+      topByWeight: db.prepare('SELECT * FROM synapses ORDER BY weight DESC LIMIT ?'),
+      topDiverse: db.prepare(`
+        SELECT * FROM (
+          SELECT *, ROW_NUMBER() OVER (PARTITION BY synapse_type ORDER BY weight DESC) as rn
+          FROM synapses
+        ) WHERE rn <= ? ORDER BY weight DESC
+      `),
+    };
+  }
+
+  create(data: SynapseCreate): number {
+    const result = this.stmts.create.run({
+      source_type: data.source_type,
+      source_id: data.source_id,
+      target_type: data.target_type,
+      target_id: data.target_id,
+      synapse_type: data.synapse_type,
+      weight: data.weight,
+      metadata: data.metadata ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): SynapseRecord | undefined {
+    return this.stmts.getById.get(id) as SynapseRecord | undefined;
+  }
+
+  update(id: number, data: SynapseUpdate): boolean {
+    const fields = Object.keys(data).filter(
+      (key) => (data as Record<string, unknown>)[key] !== undefined
+    );
+    if (fields.length === 0) return false;
+
+    const setClauses = fields.map((field) => `${field} = @${field}`).join(', ');
+    const stmt = this.db.prepare(
+      `UPDATE synapses SET ${setClauses}, updated_at = datetime('now') WHERE id = @id`
+    );
+    const result = stmt.run({ ...data, id });
+    return result.changes > 0;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+
+  getOutgoing(sourceType: string, sourceId: number): SynapseRecord[] {
+    return this.stmts.getOutgoing.all(sourceType, sourceId) as SynapseRecord[];
+  }
+
+  getIncoming(targetType: string, targetId: number): SynapseRecord[] {
+    return this.stmts.getIncoming.all(targetType, targetId) as SynapseRecord[];
+  }
+
+  findBySourceTarget(
+    sourceType: string, sourceId: number,
+    targetType: string, targetId: number,
+    synapseType: string,
+  ): SynapseRecord | undefined {
+    return this.stmts.findBySourceTarget.get(
+      sourceType, sourceId, targetType, targetId, synapseType
+    ) as SynapseRecord | undefined;
+  }
+
+  findConnected(nodeType: string, nodeId: number): SynapseRecord[] {
+    return this.stmts.findConnected.all(nodeType, nodeId, nodeType, nodeId) as SynapseRecord[];
+  }
+
+  findInactiveSince(cutoff: string): SynapseRecord[] {
+    return this.stmts.findInactiveSince.all(cutoff) as SynapseRecord[];
+  }
+
+  topByWeight(limit: number): SynapseRecord[] {
+    return this.stmts.topByWeight.all(limit) as SynapseRecord[];
+  }
+
+  topDiverse(perType: number): SynapseRecord[] {
+    return this.stmts.topDiverse.all(perType) as SynapseRecord[];
+  }
+
+  countNodes(): number {
+    const row = this.stmts.countNodes.get() as { count: number };
+    return row.count;
+  }
+
+  totalCount(): number {
+    const row = this.stmts.totalCount.get() as { count: number };
+    return row.count;
+  }
+
+  avgWeight(): number {
+    const row = this.stmts.avgWeight.get() as { avg_weight: number | null };
+    return row.avg_weight ?? 0;
+  }
+
+  countByType(): Record<string, number> {
+    const rows = this.stmts.countByType.all() as Array<{ synapse_type: string; count: number }>;
+    const result: Record<string, number> = {};
+    for (const row of rows) result[row.synapse_type] = row.count;
+    return result;
+  }
+}

package/src/db/repositories/template.repository.ts

@@ -0,0 +1,76 @@
+import type Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+import type { ContentTemplate, ContentTemplateCreate } from '../../types/post.types.js';
+
+export class TemplateRepository {
+  private stmts: Record<string, Statement>;
+
+  constructor(private db: Database.Database) {
+    this.stmts = {
+      create: db.prepare(`
+        INSERT INTO content_templates (name, structure, example, platform)
+        VALUES (@name, @structure, @example, @platform)
+      `),
+      getById: db.prepare('SELECT * FROM content_templates WHERE id = ?'),
+      listAll: db.prepare('SELECT * FROM content_templates ORDER BY avg_engagement DESC LIMIT ?'),
+      listByPlatform: db.prepare('SELECT * FROM content_templates WHERE platform = ? ORDER BY avg_engagement DESC LIMIT ?'),
+      countAll: db.prepare('SELECT COUNT(*) as count FROM content_templates'),
+      search: db.prepare(`
+        SELECT t.* FROM content_templates t
+        JOIN content_templates_fts f ON f.rowid = t.id
+        WHERE content_templates_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `),
+      delete: db.prepare('DELETE FROM content_templates WHERE id = ?'),
+    };
+  }
+
+  create(data: ContentTemplateCreate): number {
+    const result = this.stmts.create.run({
+      name: data.name,
+      structure: data.structure,
+      example: data.example ?? null,
+      platform: data.platform ?? null,
+    });
+    return result.lastInsertRowid as number;
+  }
+
+  getById(id: number): ContentTemplate | undefined {
+    return this.stmts.getById.get(id) as ContentTemplate | undefined;
+  }
+
+  listAll(limit: number = 50): ContentTemplate[] {
+    return this.stmts.listAll.all(limit) as ContentTemplate[];
+  }
+
+  listByPlatform(platform: string, limit: number = 20): ContentTemplate[] {
+    return this.stmts.listByPlatform.all(platform, limit) as ContentTemplate[];
+  }
+
+  search(query: string, limit: number = 20): ContentTemplate[] {
+    return this.stmts.search.all(query, limit) as ContentTemplate[];
+  }
+
+  incrementUseCount(id: number): void {
+    this.db.prepare(
+      `UPDATE content_templates SET use_count = use_count + 1 WHERE id = ?`
+    ).run(id);
+  }
+
+  updateAvgEngagement(id: number, avgEngagement: number): void {
+    this.db.prepare(
+      `UPDATE content_templates SET avg_engagement = ? WHERE id = ?`
+    ).run(avgEngagement, id);
+  }
+
+  countAll(): number {
+    const row = this.stmts.countAll.get() as { count: number };
+    return row.count;
+  }
+
+  delete(id: number): boolean {
+    const result = this.stmts.delete.run(id);
+    return result.changes > 0;
+  }
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { startCommand } from './cli/commands/start.js';
+import { stopCommand } from './cli/commands/stop.js';
+import { statusCommand } from './cli/commands/status.js';
+import { doctorCommand } from './cli/commands/doctor.js';
+import { postCommand } from './cli/commands/post.js';
+import { campaignCommand } from './cli/commands/campaign.js';
+import { insightsCommand } from './cli/commands/insights.js';
+import { rulesCommand } from './cli/commands/rules.js';
+import { suggestCommand } from './cli/commands/suggest.js';
+import { dashboardCommand } from './cli/commands/dashboard.js';
+import { importCommand } from './cli/commands/import.js';
+import { exportCommand } from './cli/commands/export.js';
+import { learnCommand } from './cli/commands/learn.js';
+import { networkCommand } from './cli/commands/network.js';
+import { queryCommand } from './cli/commands/query.js';
+import { configCommand } from './cli/commands/config.js';
+import { checkForUpdate, getCurrentVersion } from './cli/update-check.js';
+
+const program = new Command();
+
+program
+  .name('marketing')
+  .description('Marketing Brain — Self-Learning Marketing Intelligence System')
+  .version(getCurrentVersion());
+
+program.addCommand(startCommand());
+program.addCommand(stopCommand());
+program.addCommand(statusCommand());
+program.addCommand(doctorCommand());
+program.addCommand(postCommand());
+program.addCommand(campaignCommand());
+program.addCommand(insightsCommand());
+program.addCommand(rulesCommand());
+program.addCommand(suggestCommand());
+program.addCommand(dashboardCommand());
+program.addCommand(importCommand());
+program.addCommand(exportCommand());
+program.addCommand(learnCommand());
+program.addCommand(networkCommand());
+program.addCommand(queryCommand());
+program.addCommand(configCommand());
+
+// Hidden: MCP server (called by Claude Code)
+program
+  .command('mcp-server')
+  .description('Start MCP server (stdio transport, used by Claude Code)')
+  .action(async () => {
+    const { startMcpServer } = await import('./mcp/server.js');
+    await startMcpServer();
+  });
+
+// Hidden: run daemon in foreground
+program
+  .command('daemon')
+  .description('Run daemon in foreground')
+  .option('-c, --config <path>', 'Config file path')
+  .action(async (opts) => {
+    const { MarketingCore } = await import('./marketing-core.js');
+    const core = new MarketingCore();
+    core.start(opts.config);
+  });
+
+program.parse();
+
+// Non-blocking update check after command finishes
+checkForUpdate();

package/src/ipc/client.ts

@@ -0,0 +1,110 @@
+import net from 'node:net';
+import { randomUUID } from 'node:crypto';
+import type { IpcMessage } from '../types/ipc.types.js';
+import { encodeMessage, MessageDecoder } from './protocol.js';
+import { getPipeName } from '../utils/paths.js';
+
+interface PendingRequest {
+  resolve: (result: unknown) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class IpcClient {
+  private socket: net.Socket | null = null;
+  private decoder = new MessageDecoder();
+  private pending = new Map<string, PendingRequest>();
+
+  constructor(
+    private pipeName: string = getPipeName(),
+    private timeout: number = 5000,
+  ) {}
+
+  connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.socket = net.createConnection(this.pipeName, () => {
+        resolve();
+      });
+
+      this.socket.on('data', (chunk) => {
+        const messages = this.decoder.feed(chunk);
+        for (const msg of messages) {
+          this.handleMessage(msg);
+        }
+      });
+
+      this.socket.on('error', (err) => {
+        reject(err);
+        for (const [id, req] of this.pending) {
+          clearTimeout(req.timer);
+          req.reject(new Error(`Connection error: ${err.message}`));
+          this.pending.delete(id);
+        }
+      });
+
+      this.socket.on('close', () => {
+        for (const [id, req] of this.pending) {
+          clearTimeout(req.timer);
+          req.reject(new Error('Connection closed'));
+          this.pending.delete(id);
+        }
+        this.socket = null;
+      });
+    });
+  }
+
+  request(method: string, params?: unknown): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      if (!this.socket || this.socket.destroyed) {
+        return reject(new Error('Not connected'));
+      }
+
+      const id = randomUUID();
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Request timeout: ${method} (${this.timeout}ms)`));
+      }, this.timeout);
+
+      this.pending.set(id, { resolve, reject, timer });
+
+      const msg: IpcMessage = {
+        id,
+        type: 'request',
+        method,
+        params,
+      };
+      this.socket.write(encodeMessage(msg));
+    });
+  }
+
+  disconnect(): void {
+    for (const [id, req] of this.pending) {
+      clearTimeout(req.timer);
+      req.reject(new Error('Client disconnecting'));
+      this.pending.delete(id);
+    }
+    this.socket?.destroy();
+    this.socket = null;
+    this.decoder.reset();
+  }
+
+  get connected(): boolean {
+    return this.socket !== null && !this.socket.destroyed;
+  }
+
+  private handleMessage(msg: IpcMessage): void {
+    if (msg.type === 'response') {
+      const req = this.pending.get(msg.id);
+      if (!req) return;
+
+      clearTimeout(req.timer);
+      this.pending.delete(msg.id);
+
+      if (msg.error) {
+        req.reject(new Error(msg.error.message));
+      } else {
+        req.resolve(msg.result);
+      }
+    }
+  }
+}