the-campfire 0.1.0

package/server/cron-store.ts

@@ -0,0 +1,149 @@
+import {
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+  existsSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { CronJob, CronJobCreateInput } from "./cron-types.js";
+
+// ─── Paths ──────────────────────────────────────────────────────────────────
+
+const CAMPFIRE_DIR = join(homedir(), ".campfire");
+const CRON_DIR = join(CAMPFIRE_DIR, "cron");
+
+function ensureDir(): void {
+  mkdirSync(CRON_DIR, { recursive: true });
+}
+
+function filePath(id: string): string {
+  return join(CRON_DIR, `${id}.json`);
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function slugify(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/\s+/g, "-")
+    .replace(/[^a-z0-9-]/g, "")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+// ─── CRUD ───────────────────────────────────────────────────────────────────
+
+export function listJobs(): CronJob[] {
+  ensureDir();
+  try {
+    const files = readdirSync(CRON_DIR).filter((f) => f.endsWith(".json"));
+    const jobs: CronJob[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(CRON_DIR, file), "utf-8");
+        jobs.push(JSON.parse(raw));
+      } catch {
+        // Skip corrupt files
+      }
+    }
+    jobs.sort((a, b) => a.name.localeCompare(b.name));
+    return jobs;
+  } catch {
+    return [];
+  }
+}
+
+export function getJob(id: string): CronJob | null {
+  ensureDir();
+  try {
+    const raw = readFileSync(filePath(id), "utf-8");
+    return JSON.parse(raw) as CronJob;
+  } catch {
+    return null;
+  }
+}
+
+export function createJob(data: CronJobCreateInput): CronJob {
+  if (!data.name || !data.name.trim()) throw new Error("Job name is required");
+  if (!data.prompt || !data.prompt.trim()) throw new Error("Job prompt is required");
+  if (!data.schedule || !data.schedule.trim()) throw new Error("Job schedule is required");
+  if (!data.cwd || !data.cwd.trim()) throw new Error("Job working directory is required");
+
+  const id = slugify(data.name.trim());
+  if (!id) throw new Error("Job name must contain alphanumeric characters");
+
+  ensureDir();
+  if (existsSync(filePath(id))) {
+    throw new Error(`A job with a similar name already exists ("${id}")`);
+  }
+
+  const now = Date.now();
+  const job: CronJob = {
+    ...data,
+    id,
+    name: data.name.trim(),
+    prompt: data.prompt.trim(),
+    schedule: data.schedule.trim(),
+    cwd: data.cwd.trim(),
+    createdAt: now,
+    updatedAt: now,
+    consecutiveFailures: 0,
+    totalRuns: 0,
+  };
+  writeFileSync(filePath(id), JSON.stringify(job, null, 2), "utf-8");
+  return job;
+}
+
+export function updateJob(
+  id: string,
+  updates: Partial<CronJob>,
+): CronJob | null {
+  ensureDir();
+  const existing = getJob(id);
+  if (!existing) return null;
+
+  const newName = updates.name?.trim() || existing.name;
+  const newId = slugify(newName);
+  if (!newId) throw new Error("Job name must contain alphanumeric characters");
+
+  // If name changed, check for slug collision with a different job
+  if (newId !== id && existsSync(filePath(newId))) {
+    throw new Error(`A job with a similar name already exists ("${newId}")`);
+  }
+
+  const job: CronJob = {
+    ...existing,
+    ...updates,
+    id: newId,
+    name: newName,
+    updatedAt: Date.now(),
+    // Preserve immutable fields
+    createdAt: existing.createdAt,
+  };
+
+  // If id changed, delete old file
+  if (newId !== id) {
+    try {
+      unlinkSync(filePath(id));
+    } catch {
+      /* ok */
+    }
+  }
+
+  writeFileSync(filePath(newId), JSON.stringify(job, null, 2), "utf-8");
+  return job;
+}
+
+export function deleteJob(id: string): boolean {
+  ensureDir();
+  if (!existsSync(filePath(id))) return false;
+  try {
+    unlinkSync(filePath(id));
+    return true;
+  } catch {
+    return false;
+  }
+}

package/server/cron-types.ts

@@ -0,0 +1,63 @@
+// ─── Cron Job Types ────────────────────────────────────────────────────────
+
+export interface CronJob {
+  /** Unique slug-based ID (derived from name) */
+  id: string;
+  /** Human-readable job name */
+  name: string;
+  /** The prompt to send when the job fires */
+  prompt: string;
+  /** Cron expression (e.g. "0 8 * * *") or ISO datetime string for one-shot */
+  schedule: string;
+  /** true = recurring cron, false = one-shot at a specific time */
+  recurring: boolean;
+  /** Backend to use */
+  backendType: "claude" | "codex";
+  /** Model to use (e.g. "claude-sonnet-4-5-20250929") */
+  model: string;
+  /** Working directory for the session */
+  cwd: string;
+  /** Optional environment slug (references ~/.campfire/envs/) */
+  envSlug?: string;
+  /** Whether the job is currently enabled */
+  enabled: boolean;
+  /** Permission mode — defaults to "bypassPermissions" for autonomy */
+  permissionMode: string;
+  /** Codex-only: enable internet access */
+  codexInternetAccess?: boolean;
+
+  // ── Tracking ──
+  createdAt: number;
+  updatedAt: number;
+  /** Last time this job was triggered */
+  lastRunAt?: number;
+  /** Session ID of the last execution */
+  lastSessionId?: string;
+  /** Number of consecutive failures */
+  consecutiveFailures: number;
+  /** Total number of runs */
+  totalRuns: number;
+}
+
+export interface CronJobExecution {
+  /** The session ID created for this execution */
+  sessionId: string;
+  /** The job ID that triggered this */
+  jobId: string;
+  /** When the execution started */
+  startedAt: number;
+  /** When the execution completed (result received) */
+  completedAt?: number;
+  /** Whether the execution succeeded */
+  success?: boolean;
+  /** Error message if it failed */
+  error?: string;
+  /** Cost in USD */
+  costUsd?: number;
+}
+
+/** Input for creating a cron job (without auto-generated fields) */
+export type CronJobCreateInput = Omit<
+  CronJob,
+  "id" | "createdAt" | "updatedAt" | "consecutiveFailures" | "totalRuns" | "lastRunAt" | "lastSessionId"
+>;

package/server/deliberation-engine.ts

@@ -0,0 +1,323 @@
+/**
+ * Layer 2: Deliberation Protocol
+ *
+ * Structured debate before agents execute significant actions (large refactors,
+ * architectural changes, file deletions). Extends Campfire's existing binary
+ * permission voting into nuanced multi-stakeholder deliberation.
+ *
+ * Flow: Agent proposes → humans/agents respond → consensus engine resolves.
+ *
+ * Proposal lifecycle:
+ *   pending → [responses collected] → resolved (approved | rejected | synthesized)
+ *
+ * Resolution is triggered by:
+ *   - All requested parties have responded
+ *   - Deadline reached (if set)
+ *   - Human owner force-resolves via POST /api/sessions/:id/deliberations/:id/resolve
+ */
+
+import { randomUUID } from "node:crypto";
+import type { BackendType } from "./session-types.js";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+export type DeliberationAction = "refactor" | "feature" | "fix" | "investigate" | "delete" | "architect";
+export type DeliberationStance = "agree" | "disagree" | "suggest_alternative" | "abstain";
+export type DeliberationOutcome = "approved" | "rejected" | "synthesized";
+
+export interface DeliberationAlternative {
+  description: string;
+  tradeoffs: string;
+}
+
+export interface DeliberationProposal {
+  type: "deliberation_proposal";
+  proposalId: string;
+  sessionId: string;
+  agentId: string;
+  backendType: BackendType;
+  timestamp: number;
+  action: DeliberationAction;
+  title: string;
+  description: string;
+  approach: string;
+  alternatives: DeliberationAlternative[];
+  risks: string[];
+  affectedFiles: string[];
+  estimatedTurns?: number;
+  requestingFeedbackFrom: string[]; // viewer IDs or ["all"]
+  deadline?: number; // Unix ms, null = indefinite
+}
+
+export interface DeliberationResponse {
+  type: "deliberation_response";
+  proposalId: string;
+  responderId: string;
+  responderType: "agent" | "human";
+  backendType?: BackendType;
+  timestamp: number;
+  stance: DeliberationStance;
+  reasoning: string;
+  suggestedAlternative?: string;
+  concerns?: string[];
+}
+
+export interface DeliberationResolution {
+  type: "deliberation_resolved";
+  proposalId: string;
+  timestamp: number;
+  outcome: DeliberationOutcome;
+  finalApproach: string;
+  participants: string[];
+  voteBreakdown: {
+    agree: number;
+    disagree: number;
+    suggest_alternative: number;
+    abstain: number;
+  };
+  synthesis?: string;
+}
+
+export type ResolutionCallback = (resolution: DeliberationResolution) => void;
+
+// ─── Deliberation Engine ──────────────────────────────────────────────────────
+
+interface ActiveDeliberation {
+  proposal: DeliberationProposal;
+  responses: DeliberationResponse[];
+  deadlineTimer?: ReturnType<typeof setTimeout>;
+}
+
+/**
+ * Manages active deliberations for all sessions.
+ * One instance shared across the server (singleton pattern matching existing managers).
+ *
+ * Consensus weights:
+ *   - Human owner:        2.0x
+ *   - Human collaborator: 1.5x
+ *   - Human spectator:    0.5x
+ *   - Agent:              1.0x (weighted by historical accuracy in future)
+ * Threshold: 60% weighted majority to approve or reject. Below threshold → synthesize.
+ */
+export class DeliberationEngine {
+  // key = proposalId
+  private active = new Map<string, ActiveDeliberation>();
+  // callbacks for broadcasting resolutions to browsers
+  private onResolution: ResolutionCallback | null = null;
+
+  setOnResolution(cb: ResolutionCallback): void {
+    this.onResolution = cb;
+  }
+
+  /**
+   * Register a new proposal. Returns the proposal with a generated proposalId.
+   * Starts deadline timer if deadline is set.
+   */
+  register(proposal: Omit<DeliberationProposal, "proposalId" | "type">): DeliberationProposal {
+    const full: DeliberationProposal = {
+      ...proposal,
+      type: "deliberation_proposal",
+      proposalId: randomUUID(),
+    };
+
+    const entry: ActiveDeliberation = { proposal: full, responses: [] };
+
+    if (full.deadline) {
+      const ms = full.deadline - Date.now();
+      if (ms > 0) {
+        entry.deadlineTimer = setTimeout(() => {
+          this.resolveById(full.proposalId);
+        }, ms);
+      }
+    }
+
+    this.active.set(full.proposalId, entry);
+    return full;
+  }
+
+  /**
+   * Add a response to a proposal.
+   * If all requested parties have responded, triggers resolution.
+   */
+  addResponse(response: Omit<DeliberationResponse, "type">): DeliberationResponse | null {
+    const entry = this.active.get(response.proposalId);
+    if (!entry) return null;
+
+    const full: DeliberationResponse = { ...response, type: "deliberation_response" };
+
+    // Deduplicate: one response per responder
+    const existing = entry.responses.findIndex((r) => r.responderId === full.responderId);
+    if (existing >= 0) {
+      entry.responses[existing] = full;
+    } else {
+      entry.responses.push(full);
+    }
+
+    // Check if all requested parties have responded
+    const requested = entry.proposal.requestingFeedbackFrom;
+    if (requested.length > 0 && !requested.includes("all")) {
+      const respondedIds = new Set(entry.responses.map((r) => r.responderId));
+      const allResponded = requested.every((id) => respondedIds.has(id));
+      if (allResponded) {
+        this.resolveById(response.proposalId);
+      }
+    }
+
+    return full;
+  }
+
+  /**
+   * Force-resolve a deliberation (e.g. owner clicking "Resolve Now").
+   */
+  resolveById(proposalId: string): DeliberationResolution | null {
+    const entry = this.active.get(proposalId);
+    if (!entry) return null;
+
+    if (entry.deadlineTimer) clearTimeout(entry.deadlineTimer);
+
+    const resolution = this.evaluate(entry.proposal, entry.responses);
+    this.active.delete(proposalId);
+    this.onResolution?.(resolution);
+    return resolution;
+  }
+
+  getProposal(proposalId: string): DeliberationProposal | null {
+    return this.active.get(proposalId)?.proposal ?? null;
+  }
+
+  getResponses(proposalId: string): DeliberationResponse[] {
+    return this.active.get(proposalId)?.responses ?? [];
+  }
+
+  getActiveProposals(sessionId: string): DeliberationProposal[] {
+    return Array.from(this.active.values())
+      .filter((e) => e.proposal.sessionId === sessionId)
+      .map((e) => e.proposal);
+  }
+
+  // ─── Consensus Algorithm ────────────────────────────────────────────────────
+
+  /**
+   * Evaluate responses to a proposal and produce a resolution.
+   *
+   * Weights: human owner = 2.0, collaborator = 1.5, spectator = 0.5, agent = 1.0
+   * Threshold: 60% weighted score to approve or reject. Otherwise synthesize.
+   */
+  evaluate(
+    proposal: DeliberationProposal,
+    responses: DeliberationResponse[],
+    /** Optional map of responderId → role for human weight calculation */
+    roles?: Map<string, "owner" | "collaborator" | "spectator">,
+  ): DeliberationResolution {
+    if (responses.length === 0) {
+      // No responses — auto-approve (agent proceeds unblocked)
+      return {
+        type: "deliberation_resolved",
+        proposalId: proposal.proposalId,
+        timestamp: Date.now(),
+        outcome: "approved",
+        finalApproach: proposal.approach,
+        participants: [],
+        voteBreakdown: { agree: 0, disagree: 0, suggest_alternative: 0, abstain: 0 },
+      };
+    }
+
+    const weights = new Map<string, number>();
+    for (const r of responses) {
+      if (r.responderType === "human") {
+        const role = roles?.get(r.responderId);
+        weights.set(r.responderId, role === "owner" ? 2.0 : role === "collaborator" ? 1.5 : 0.5);
+      } else {
+        weights.set(r.responderId, 1.0);
+      }
+    }
+
+    const totalWeight = Array.from(weights.values()).reduce((s, w) => s + w, 0);
+
+    const breakdown = { agree: 0, disagree: 0, suggest_alternative: 0, abstain: 0 };
+    let agreeScore = 0;
+    let disagreeScore = 0;
+
+    for (const r of responses) {
+      const w = weights.get(r.responderId) ?? 1.0;
+      breakdown[r.stance]++;
+      if (r.stance === "agree") agreeScore += w;
+      if (r.stance === "disagree") disagreeScore += w;
+    }
+
+    const THRESHOLD = 0.6;
+
+    if (totalWeight > 0 && agreeScore / totalWeight >= THRESHOLD) {
+      return {
+        type: "deliberation_resolved",
+        proposalId: proposal.proposalId,
+        timestamp: Date.now(),
+        outcome: "approved",
+        finalApproach: proposal.approach,
+        participants: responses.map((r) => r.responderId),
+        voteBreakdown: breakdown,
+      };
+    }
+
+    if (totalWeight > 0 && disagreeScore / totalWeight >= THRESHOLD) {
+      return {
+        type: "deliberation_resolved",
+        proposalId: proposal.proposalId,
+        timestamp: Date.now(),
+        outcome: "rejected",
+        finalApproach: "",
+        participants: responses.map((r) => r.responderId),
+        voteBreakdown: breakdown,
+      };
+    }
+
+    // Below threshold — synthesize from alternatives
+    const alternatives = responses
+      .filter((r) => r.stance === "suggest_alternative" && r.suggestedAlternative)
+      .map((r) => r.suggestedAlternative!);
+
+    const synthesis = this.synthesizeAlternatives(proposal, alternatives, responses);
+
+    return {
+      type: "deliberation_resolved",
+      proposalId: proposal.proposalId,
+      timestamp: Date.now(),
+      outcome: "synthesized",
+      finalApproach: synthesis,
+      participants: responses.map((r) => r.responderId),
+      voteBreakdown: breakdown,
+      synthesis,
+    };
+  }
+
+  private synthesizeAlternatives(
+    proposal: DeliberationProposal,
+    alternatives: string[],
+    responses: DeliberationResponse[],
+  ): string {
+    // Simple synthesis: combine original approach with top-confidence alternatives.
+    // In production, replace with an LLM call that considers all responses.
+    const concerns = responses
+      .flatMap((r) => r.concerns ?? [])
+      .slice(0, 5)
+      .map((c) => `  - ${c}`)
+      .join("\n");
+
+    const alts = alternatives
+      .slice(0, 3)
+      .map((a, i) => `  ${i + 1}. ${a}`)
+      .join("\n");
+
+    return [
+      `Synthesized approach for: ${proposal.title}`,
+      "",
+      `Original: ${proposal.approach}`,
+      concerns ? `\nConcerns raised:\n${concerns}` : "",
+      alts ? `\nSuggested alternatives:\n${alts}` : "",
+      "\nRecommendation: Address the concerns raised before proceeding with the original approach.",
+    ].filter(Boolean).join("\n");
+  }
+}
+
+// Singleton instance
+export const deliberationEngine = new DeliberationEngine();

package/server/embedding.ts

@@ -0,0 +1,89 @@
+/**
+ * Embedding provider abstraction for semantic memory.
+ *
+ * Supports two providers:
+ * - "openai": text-embedding-3-small (1536-dim) via OpenAI API
+ * - "ollama": nomic-embed-text (768-dim) via local Ollama at http://localhost:11434
+ * - "none": returns zero-vectors (disables vector search, fragments stored without embeddings)
+ *
+ * Provider is configured in ~/.campfire/settings.json via embeddingProvider field.
+ */
+
+import { getSettings } from "./settings-manager.js";
+
+export const OPENAI_DIM = 1536;
+export const OLLAMA_DIM = 768;
+
+/**
+ * Generate an embedding vector for the given text using the configured provider.
+ * Returns null if provider is "none" or if the embedding call fails.
+ */
+export async function embed(text: string): Promise<number[] | null> {
+  const settings = getSettings();
+
+  if (settings.embeddingProvider === "openai") {
+    return embedWithOpenAI(text, settings.embeddingApiKey, settings.embeddingModel || "text-embedding-3-small");
+  }
+
+  if (settings.embeddingProvider === "ollama") {
+    return embedWithOllama(text, settings.embeddingBaseUrl || "http://localhost:11434", settings.embeddingModel || "nomic-embed-text");
+  }
+
+  return null;
+}
+
+/**
+ * Return the embedding dimension for the currently configured provider.
+ * Used when creating LanceDB tables so the vector column has the correct width.
+ */
+export function getEmbeddingDim(): number {
+  const settings = getSettings();
+  if (settings.embeddingProvider === "openai") return OPENAI_DIM;
+  if (settings.embeddingProvider === "ollama") return OLLAMA_DIM;
+  return OPENAI_DIM; // default dimension when "none" (stored as zeros)
+}
+
+async function embedWithOpenAI(text: string, apiKey: string, model: string): Promise<number[] | null> {
+  if (!apiKey) {
+    console.warn("[embedding] OpenAI provider configured but no API key set");
+    return null;
+  }
+  try {
+    const res = await fetch("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ model, input: text }),
+    });
+    if (!res.ok) {
+      console.warn(`[embedding] OpenAI API error ${res.status}: ${await res.text()}`);
+      return null;
+    }
+    const json = await res.json() as { data: Array<{ embedding: number[] }> };
+    return json.data[0]?.embedding ?? null;
+  } catch (err) {
+    console.warn("[embedding] OpenAI request failed:", err);
+    return null;
+  }
+}
+
+async function embedWithOllama(text: string, baseUrl: string, model: string): Promise<number[] | null> {
+  try {
+    const res = await fetch(`${baseUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model, prompt: text }),
+    });
+    if (!res.ok) {
+      console.warn(`[embedding] Ollama API error ${res.status}: ${await res.text()}`);
+      return null;
+    }
+    const json = await res.json() as { embedding: number[] };
+    return json.embedding ?? null;
+  } catch (err) {
+    console.warn("[embedding] Ollama request failed:", err);
+    return null;
+  }
+}