profclaw 0.0.1-beta.1

package/dist/states/index.js

@@ -0,0 +1,142 @@
+/**
+ * States Service
+ *
+ * Manages customizable workflow states for projects.
+ * Maps custom states to core StateGroups (backlog, unstarted, started, completed, cancelled).
+ */
+import { randomUUID } from 'crypto';
+import { eq, asc, isNull } from 'drizzle-orm';
+import { getDb } from '../storage/index.js';
+import { states } from '../storage/schema.js';
+// STATE CRUD
+/**
+ * Create a new state
+ */
+export async function createState(input) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const id = randomUUID();
+    const slug = input.slug || input.name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+    const now = new Date();
+    // If this is the new default, unset existing default for this project
+    if (input.isDefault) {
+        await db
+            .update(states)
+            .set({ isDefault: false })
+            .where(input.projectId ? eq(states.projectId, input.projectId) : isNull(states.projectId));
+    }
+    const newState = {
+        id,
+        projectId: input.projectId || null,
+        name: input.name,
+        slug,
+        color: input.color || '#6B7280',
+        description: input.description || null,
+        stateGroup: input.stateGroup,
+        isDefault: !!input.isDefault,
+        sequence: input.sequence ?? 65535,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await db.insert(states).values(newState);
+    return newState;
+}
+/**
+ * Get a state by ID
+ */
+export async function getState(id) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const result = await db.select().from(states).where(eq(states.id, id)).limit(1);
+    return result[0] || null;
+}
+/**
+ * List states for a project
+ */
+export async function listStates(projectId) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const result = await db
+        .select()
+        .from(states)
+        .where(projectId ? eq(states.projectId, projectId) : isNull(states.projectId))
+        .orderBy(asc(states.sequence), asc(states.name));
+    return result;
+}
+/**
+ * Update a state
+ */
+export async function updateState(id, input) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const existing = await getState(id);
+    if (!existing)
+        throw new Error(`State ${id} not found`);
+    // If setting as default, unset others first
+    if (input.isDefault) {
+        await db
+            .update(states)
+            .set({ isDefault: false })
+            .where(existing.projectId ? eq(states.projectId, existing.projectId) : isNull(states.projectId));
+    }
+    const updates = { updatedAt: new Date() };
+    if (input.name !== undefined)
+        updates.name = input.name;
+    if (input.slug !== undefined)
+        updates.slug = input.slug;
+    if (input.color !== undefined)
+        updates.color = input.color;
+    if (input.description !== undefined)
+        updates.description = input.description;
+    if (input.statusGroup !== undefined)
+        updates.stateGroup = input.statusGroup;
+    if (input.isDefault !== undefined)
+        updates.isDefault = input.isDefault;
+    if (input.sequence !== undefined)
+        updates.sequence = input.sequence;
+    await db.update(states).set(updates).where(eq(states.id, id));
+    const updated = await getState(id);
+    if (!updated)
+        throw new Error(`State ${id} not found after update`);
+    return updated;
+}
+/**
+ * Delete a state
+ */
+export async function deleteState(id) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const state = await getState(id);
+    if (!state)
+        return;
+    if (state.isDefault) {
+        throw new Error('Cannot delete the default state. Set another state as default first.');
+    }
+    await db.delete(states).where(eq(states.id, id));
+}
+// PROJECT INITIALIZATION
+/**
+ * Initialize default states for a new project
+ */
+export async function initializeProjectStates(projectId) {
+    const defaultStates = [
+        { name: 'Backlog', slug: 'backlog', color: '#94a3b8', stateGroup: 'backlog', sequence: 1000 },
+        { name: 'Todo', slug: 'todo', color: '#3b82f6', stateGroup: 'unstarted', sequence: 2000, isDefault: true },
+        { name: 'In Progress', slug: 'in-progress', color: '#f59e0b', stateGroup: 'started', sequence: 3000 },
+        { name: 'In Review', slug: 'in-review', color: '#8b5cf6', stateGroup: 'started', sequence: 4000 },
+        { name: 'Done', slug: 'done', color: '#10b981', stateGroup: 'completed', sequence: 5000 },
+        { name: 'Cancelled', slug: 'cancelled', color: '#6b7280', stateGroup: 'cancelled', sequence: 6000 },
+    ];
+    const results = [];
+    for (const input of defaultStates) {
+        const state = await createState({ ...input, projectId });
+        results.push(state);
+    }
+    return results;
+}
+//# sourceMappingURL=index.js.map

package/dist/storage/adapter.d.ts

@@ -0,0 +1,146 @@
+import type { Task, CreateTaskInput, TaskEvent as TaskEventType } from '../types/task.js';
+import type { Summary, CreateSummaryInput, SummaryQuery, SummaryStats } from '../types/summary.js';
+/**
+ * Task Event for audit logging
+ */
+export interface TaskEventInput {
+    taskId: string;
+    type: 'created' | 'queued' | 'assigned' | 'started' | 'progress' | 'completed' | 'failed' | 'cancelled' | 'retried';
+    agentId?: string;
+    message?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Task Analytics Summary
+ */
+export interface TaskAnalytics {
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    pendingTasks: number;
+    inProgressTasks: number;
+    cancelledTasks: number;
+    successRate: number;
+    avgDurationMs: number;
+    minDurationMs: number;
+    maxDurationMs: number;
+    byStatus: Record<string, number>;
+    byPriority: Record<number, number>;
+    bySource: Record<string, number>;
+    byAgent: Record<string, {
+        count: number;
+        successRate: number;
+        avgDurationMs: number;
+    }>;
+    daily: Array<{
+        date: string;
+        created: number;
+        completed: number;
+        failed: number;
+    }>;
+    recentCompletions: number;
+    recentFailures: number;
+}
+/**
+ * Task filter options for advanced queries
+ */
+export interface TaskFilterOptions {
+    status?: string | string[];
+    priority?: number | number[];
+    source?: string | string[];
+    agent?: string;
+    labels?: string[];
+    createdAfter?: Date;
+    createdBefore?: Date;
+    completedAfter?: Date;
+    completedBefore?: Date;
+    repository?: string;
+    searchQuery?: string;
+    limit?: number;
+    offset?: number;
+    sortBy?: 'createdAt' | 'updatedAt' | 'priority' | 'completedAt';
+    sortOrder?: 'asc' | 'desc';
+    cursorCreatedAt?: Date;
+    cursorId?: string;
+}
+/**
+ * Generic Storage Adapter Interface
+ */
+export interface StorageAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    createTask(input: CreateTaskInput): Promise<Task>;
+    getTask(id: string): Promise<Task | null>;
+    updateTask(id: string, updates: Partial<Task>): Promise<Task>;
+    deleteTask(id: string): Promise<boolean>;
+    getTasks(query?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<{
+        tasks: Task[];
+        total: number;
+    }>;
+    createSummary(input: CreateSummaryInput): Promise<Summary>;
+    getSummary(id: string, includeRawOutput?: boolean): Promise<Summary | null>;
+    getTaskSummaries(taskId: string): Promise<Summary[]>;
+    querySummaries(query: Partial<SummaryQuery>): Promise<{
+        summaries: Summary[];
+        total: number;
+    }>;
+    deleteSummary(id: string): Promise<boolean>;
+    getSummaryStats(): Promise<SummaryStats>;
+    getSummaryRawOutput(summaryId: string): Promise<string | null>;
+    storeEmbedding?(id: string, entityType: 'task' | 'summary', entityId: string, embedding: number[], model: string): Promise<void>;
+    searchSimilar?(entityType: 'task' | 'summary', embedding: number[], limit?: number): Promise<Array<{
+        entityId: string;
+        distance: number;
+    }>>;
+    healthCheck(): Promise<{
+        healthy: boolean;
+        latencyMs: number;
+    }>;
+    getAgentStats(): Promise<Record<string, {
+        completed: number;
+        failed: number;
+        avgDuration: number;
+        lastActivity?: Date;
+    }>>;
+    getCostAnalytics(): Promise<{
+        daily: Array<{
+            date: string;
+            cost: number;
+            tokens: number;
+        }>;
+        byModel: Record<string, {
+            cost: number;
+            tokens: number;
+        }>;
+        byAgent: Record<string, {
+            cost: number;
+            tokens: number;
+        }>;
+        totalCost: number;
+        totalTokens: number;
+    }>;
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    execute(sql: string, params?: unknown[]): Promise<void>;
+    recordTaskEvent?(event: TaskEventInput): Promise<void>;
+    getTaskEvents?(taskId: string): Promise<TaskEventType[]>;
+    getTaskAnalytics?(): Promise<TaskAnalytics>;
+    getTasksFiltered?(options: TaskFilterOptions): Promise<{
+        tasks: Task[];
+        total: number;
+    }>;
+    archiveOldTasks?(olderThanDays: number): Promise<{
+        archived: number;
+    }>;
+    getArchivedTasks?(options: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        tasks: Task[];
+        total: number;
+    }>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/storage/adapter.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter.js.map

package/dist/storage/index.d.ts

@@ -0,0 +1,48 @@
+import type { StorageAdapter } from "./adapter.js";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { Client } from "@libsql/client";
+/**
+ * Initialize storage based on configuration
+ */
+export declare function initStorage(): Promise<StorageAdapter>;
+/**
+ * Get the global storage instance
+ */
+export declare function getStorage(): StorageAdapter;
+/**
+ * Get the raw drizzle database instance for advanced queries
+ */
+export declare function getDb(): LibSQLDatabase<Record<string, unknown>>;
+/**
+ * Get the raw libsql client for executing raw SQL
+ */
+export declare function getClient(): Client;
+export * from "./adapter.js";
+export * from "./schema.js";
+export interface SavedProviderConfig {
+    type: string;
+    apiKey?: string;
+    baseUrl?: string;
+    resourceName?: string;
+    deploymentName?: string;
+    apiVersion?: string;
+    defaultModel?: string;
+    enabled?: boolean;
+}
+/**
+ * Save an AI provider configuration to the database
+ */
+export declare function saveProviderConfig(config: SavedProviderConfig): Promise<void>;
+/**
+ * Load an AI provider configuration from the database
+ */
+export declare function loadProviderConfig(type: string): Promise<SavedProviderConfig | null>;
+/**
+ * Load all saved AI provider configurations
+ */
+export declare function loadAllProviderConfigs(): Promise<SavedProviderConfig[]>;
+/**
+ * Delete a saved provider configuration
+ */
+export declare function deleteProviderConfig(type: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -0,0 +1,135 @@
+import { LibSQLAdapter } from "./libsql.js";
+import { loadConfig } from "../utils/config-loader.js";
+let storage = null;
+/**
+ * Initialize storage based on configuration
+ */
+export async function initStorage() {
+    if (storage) {
+        return storage;
+    }
+    const settings = loadConfig("settings.yml");
+    // Support DATABASE_URL env var (e.g. "file:/app/data/profclaw.db" from Docker)
+    const databaseUrl = process.env.DATABASE_URL;
+    let tier = process.env.STORAGE_TIER || settings.storage?.tier || "memory";
+    let dbPathOverride;
+    // Normalize tier aliases: "file" and "local" both mean persistent SQLite
+    if (tier === "file") {
+        tier = "local";
+    }
+    if (databaseUrl && tier === "memory") {
+        // DATABASE_URL implies persistent storage
+        tier = "local";
+        dbPathOverride = databaseUrl.startsWith("file:")
+            ? databaseUrl.slice(5)
+            : databaseUrl;
+    }
+    if (tier === "local") {
+        const dbPath = dbPathOverride || process.env.DB_PATH || settings.storage?.dbPath;
+        storage = new LibSQLAdapter({ dbPath });
+        console.log(`[Storage] Initializing LibSQL storage at ${dbPath || "default path"}`);
+    }
+    else {
+        console.log("[Storage] Initializing in-memory storage (LibSQL in-memory)");
+        storage = new LibSQLAdapter({ dbPath: ":memory:" });
+    }
+    await storage.connect();
+    return storage;
+}
+/**
+ * Get the global storage instance
+ */
+export function getStorage() {
+    if (!storage) {
+        throw new Error("Storage not initialized. Call initStorage() first.");
+    }
+    return storage;
+}
+/**
+ * Get the raw drizzle database instance for advanced queries
+ */
+export function getDb() {
+    if (!storage) {
+        throw new Error("Storage not initialized. Call initStorage() first.");
+    }
+    // Access the internal db property via the LibSQLAdapter
+    return storage.getDb();
+}
+/**
+ * Get the raw libsql client for executing raw SQL
+ */
+export function getClient() {
+    if (!storage) {
+        throw new Error("Storage not initialized. Call initStorage() first.");
+    }
+    return storage.getClient();
+}
+export * from "./adapter.js";
+export * from "./schema.js";
+/**
+ * Save an AI provider configuration to the database
+ */
+export async function saveProviderConfig(config) {
+    const client = getClient();
+    // Store as JSON in settings table with category 'ai_providers'
+    await client.execute({
+        sql: `
+      INSERT INTO settings (key, value, category, is_secret, updated_at)
+      VALUES (?, ?, 'ai_providers', 1, unixepoch())
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = unixepoch()
+    `,
+        args: [`provider_${config.type}`, JSON.stringify(config)],
+    });
+}
+/**
+ * Load an AI provider configuration from the database
+ */
+export async function loadProviderConfig(type) {
+    const client = getClient();
+    const result = await client.execute({
+        sql: `SELECT value FROM settings WHERE key = ? AND category = 'ai_providers'`,
+        args: [`provider_${type}`],
+    });
+    if (result.rows.length === 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(result.rows[0].value);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load all saved AI provider configurations
+ */
+export async function loadAllProviderConfigs() {
+    const client = getClient();
+    const result = await client.execute({
+        sql: `SELECT value FROM settings WHERE category = 'ai_providers'`,
+        args: [],
+    });
+    return result.rows
+        .map((row) => {
+        try {
+            return JSON.parse(row.value);
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((config) => config !== null);
+}
+/**
+ * Delete a saved provider configuration
+ */
+export async function deleteProviderConfig(type) {
+    const client = getClient();
+    await client.execute({
+        sql: `DELETE FROM settings WHERE key = ? AND category = 'ai_providers'`,
+        args: [`provider_${type}`],
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/storage/libsql.d.ts

@@ -0,0 +1,99 @@
+import { type LibSQLDatabase } from "drizzle-orm/libsql";
+import { type Client } from "@libsql/client";
+import type { StorageAdapter, TaskEventInput, TaskAnalytics, TaskFilterOptions } from "./adapter.js";
+import * as schema from "./schema.js";
+import type { Task, CreateTaskInput, TaskEvent } from "../types/task.js";
+import type { Summary, CreateSummaryInput, SummaryQuery, SummaryStats } from "../types/summary.js";
+export declare class LibSQLAdapter implements StorageAdapter {
+    private _db;
+    private _client;
+    private readonly dbUrl;
+    constructor(config?: {
+        dbPath?: string;
+    });
+    connect(): Promise<void>;
+    private initDatabase;
+    private get db();
+    private get client();
+    getDb(): LibSQLDatabase<typeof schema>;
+    getClient(): Client;
+    disconnect(): Promise<void>;
+    createTask(input: CreateTaskInput): Promise<Task>;
+    getTask(id: string): Promise<Task | null>;
+    updateTask(id: string, updates: Partial<Task>): Promise<Task>;
+    deleteTask(id: string): Promise<boolean>;
+    getTasks(query?: {
+        limit?: number;
+        offset?: number;
+        status?: string;
+    }): Promise<{
+        tasks: Task[];
+        total: number;
+    }>;
+    createSummary(input: CreateSummaryInput): Promise<Summary>;
+    getSummary(id: string, includeRawOutput?: boolean): Promise<Summary | null>;
+    /**
+     * Get raw output for a summary (lazy loading)
+     */
+    getSummaryRawOutput(summaryId: string): Promise<string | null>;
+    getTaskSummaries(taskId: string): Promise<Summary[]>;
+    querySummaries(query: Partial<SummaryQuery>): Promise<{
+        summaries: Summary[];
+        total: number;
+    }>;
+    deleteSummary(id: string): Promise<boolean>;
+    getSummaryStats(): Promise<SummaryStats>;
+    healthCheck(): Promise<{
+        healthy: boolean;
+        latencyMs: number;
+    }>;
+    getAgentStats(): Promise<Record<string, {
+        completed: number;
+        failed: number;
+        avgDuration: number;
+        lastActivity?: Date;
+    }>>;
+    getCostAnalytics(): Promise<{
+        daily: Array<{
+            date: string;
+            cost: number;
+            tokens: number;
+        }>;
+        byModel: Record<string, {
+            cost: number;
+            tokens: number;
+        }>;
+        byAgent: Record<string, {
+            cost: number;
+            tokens: number;
+        }>;
+        totalCost: number;
+        totalTokens: number;
+    }>;
+    storeEmbedding(id: string, entityType: "task" | "summary", entityId: string, embedding: number[], model: string): Promise<void>;
+    searchSimilar(entityType: "task" | "summary", embedding: number[], limit?: number): Promise<Array<{
+        entityId: string;
+        distance: number;
+    }>>;
+    private cosineSimilarity;
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+    execute(sql: string, params?: unknown[]): Promise<void>;
+    recordTaskEvent(event: TaskEventInput): Promise<void>;
+    getTaskEvents(taskId: string): Promise<TaskEvent[]>;
+    getTaskAnalytics(): Promise<TaskAnalytics>;
+    getTasksFiltered(options: TaskFilterOptions): Promise<{
+        tasks: Task[];
+        total: number;
+    }>;
+    archiveOldTasks(olderThanDays: number): Promise<{
+        archived: number;
+    }>;
+    getArchivedTasks(options: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        tasks: Task[];
+        total: number;
+    }>;
+}
+//# sourceMappingURL=libsql.d.ts.map