@lawrence369/loop-cli 0.1.0

package/dist/orchestrator/ipc-server.js

@@ -0,0 +1,166 @@
+import { createServer } from "node:net";
+import { unlinkSync } from "node:fs";
+/**
+ * Unix domain socket IPC server.
+ *
+ * Protocol: newline-delimited JSON (each message is a JSON object
+ * followed by a newline character).
+ */
+export class IpcServer {
+    socketPath;
+    handler;
+    server = null;
+    sockets = new Set();
+    constructor(socketPath, handler) {
+        this.socketPath = socketPath;
+        this.handler = handler;
+    }
+    /**
+     * Start listening on the Unix socket.
+     */
+    async start() {
+        // Remove stale socket file if it exists
+        try {
+            unlinkSync(this.socketPath);
+        }
+        catch {
+            // Ignore - file may not exist
+        }
+        return new Promise((resolve, reject) => {
+            this.server = createServer((socket) => this.handleConnection(socket));
+            this.server.on("error", (err) => {
+                reject(err);
+            });
+            this.server.listen(this.socketPath, () => {
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the IPC server and close all connections.
+     */
+    async stop() {
+        // Close all client sockets
+        for (const socket of this.sockets) {
+            try {
+                socket.destroy();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        this.sockets.clear();
+        // Close the server
+        if (this.server) {
+            return new Promise((resolve) => {
+                this.server.close(() => {
+                    // Remove socket file
+                    try {
+                        unlinkSync(this.socketPath);
+                    }
+                    catch {
+                        // Ignore
+                    }
+                    resolve();
+                });
+            });
+        }
+        // Remove socket file even if server wasn't created
+        try {
+            unlinkSync(this.socketPath);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    /**
+     * Send a message to all connected clients.
+     */
+    broadcast(payload) {
+        const line = JSON.stringify(payload) + "\n";
+        for (const socket of this.sockets) {
+            if (socket.destroyed)
+                continue;
+            try {
+                socket.write(line);
+            }
+            catch {
+                // Ignore write errors
+            }
+        }
+    }
+    /**
+     * Get the number of connected clients.
+     */
+    get clientCount() {
+        return this.sockets.size;
+    }
+    /**
+     * Handle a new socket connection.
+     */
+    handleConnection(socket) {
+        this.sockets.add(socket);
+        let buffer = "";
+        socket.on("data", (data) => {
+            buffer += data.toString("utf8");
+            // Process complete lines
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? ""; // Keep incomplete last line in buffer
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                this.processLine(trimmed, socket).catch((err) => {
+                    const message = err instanceof Error ? err.message : String(err);
+                    const errorResponse = {
+                        success: false,
+                        type: "ERROR",
+                        error: message,
+                    };
+                    try {
+                        socket.write(JSON.stringify(errorResponse) + "\n");
+                    }
+                    catch {
+                        // Ignore write errors
+                    }
+                });
+            }
+        });
+        socket.on("close", () => {
+            this.sockets.delete(socket);
+        });
+        socket.on("error", () => {
+            this.sockets.delete(socket);
+        });
+    }
+    /**
+     * Process a single JSON line from a client.
+     */
+    async processLine(line, socket) {
+        let req;
+        try {
+            req = JSON.parse(line);
+        }
+        catch {
+            const errorResponse = {
+                success: false,
+                type: "ERROR",
+                error: "Invalid JSON",
+            };
+            socket.write(JSON.stringify(errorResponse) + "\n");
+            return;
+        }
+        if (!req || typeof req !== "object" || !req.type) {
+            const errorResponse = {
+                success: false,
+                type: "ERROR",
+                error: "Missing request type",
+            };
+            socket.write(JSON.stringify(errorResponse) + "\n");
+            return;
+        }
+        const response = await this.handler(req);
+        socket.write(JSON.stringify(response) + "\n");
+    }
+}
+//# sourceMappingURL=ipc-server.js.map

package/dist/orchestrator/scheduler.d.ts

@@ -0,0 +1,32 @@
+import { SubscriberManager } from "../bus/subscriber.js";
+/**
+ * Simple activity-aware task scheduler.
+ *
+ * Routes tasks to idle agents, preferring agents that have been idle
+ * the longest. Falls back to the least-recently-active agent if none
+ * are idle.
+ */
+export declare class Scheduler {
+    private readonly subscriberManager;
+    constructor(subscriberManager: SubscriberManager);
+    /**
+     * Assign a task to the best available agent.
+     *
+     * @param task - Description of the task (for logging; not persisted here)
+     * @param preferredAgent - Optional subscriber ID or agent type to prefer
+     * @returns The subscriber ID of the assigned agent, or null if none available
+     */
+    assignTask(_task: string, preferredAgent?: string): Promise<string | null>;
+    /**
+     * Find the best idle agent to route work to.
+     *
+     * @returns The subscriber ID of an idle agent, or null if none available
+     */
+    routeToIdle(): Promise<string | null>;
+    /**
+     * From a list of active agents, pick the best one to receive work.
+     * Prefers idle agents; among idle agents, picks the one idle longest.
+     */
+    private routeToIdleFromList;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/orchestrator/scheduler.js

@@ -0,0 +1,95 @@
+/**
+ * Simple activity-aware task scheduler.
+ *
+ * Routes tasks to idle agents, preferring agents that have been idle
+ * the longest. Falls back to the least-recently-active agent if none
+ * are idle.
+ */
+export class Scheduler {
+    subscriberManager;
+    constructor(subscriberManager) {
+        this.subscriberManager = subscriberManager;
+    }
+    /**
+     * Assign a task to the best available agent.
+     *
+     * @param task - Description of the task (for logging; not persisted here)
+     * @param preferredAgent - Optional subscriber ID or agent type to prefer
+     * @returns The subscriber ID of the assigned agent, or null if none available
+     */
+    async assignTask(_task, preferredAgent) {
+        const agents = await this.subscriberManager.list();
+        // Filter to active agents only
+        const active = [];
+        for (const [id, meta] of agents) {
+            if (meta.status === "active") {
+                active.push([id, meta]);
+            }
+        }
+        if (active.length === 0)
+            return null;
+        // If a preferred agent is specified, check it first
+        if (preferredAgent) {
+            // Try exact match
+            const exact = active.find(([id]) => id === preferredAgent);
+            if (exact)
+                return exact[0];
+            // Try nickname match
+            const byNickname = active.find(([, meta]) => meta.nickname === preferredAgent);
+            if (byNickname)
+                return byNickname[0];
+            // Try agent type match (pick idle one of that type)
+            const byType = active.filter(([, meta]) => meta.agent_type === preferredAgent);
+            if (byType.length > 0) {
+                const idle = byType.find(([, meta]) => meta.activity_state === "idle");
+                if (idle)
+                    return idle[0];
+                return byType[0][0]; // Fallback to first of type
+            }
+        }
+        // Prefer idle agents
+        return this.routeToIdleFromList(active);
+    }
+    /**
+     * Find the best idle agent to route work to.
+     *
+     * @returns The subscriber ID of an idle agent, or null if none available
+     */
+    async routeToIdle() {
+        const agents = await this.subscriberManager.list();
+        const active = [];
+        for (const [id, meta] of agents) {
+            if (meta.status === "active") {
+                active.push([id, meta]);
+            }
+        }
+        return this.routeToIdleFromList(active);
+    }
+    /**
+     * From a list of active agents, pick the best one to receive work.
+     * Prefers idle agents; among idle agents, picks the one idle longest.
+     */
+    routeToIdleFromList(active) {
+        if (active.length === 0)
+            return null;
+        // Separate idle from working
+        const idle = active.filter(([, meta]) => meta.activity_state === "idle");
+        if (idle.length > 0) {
+            // Pick the agent that has been idle the longest (oldest last_activity)
+            idle.sort((a, b) => {
+                const aTime = a[1].last_activity ?? a[1].last_seen;
+                const bTime = b[1].last_activity ?? b[1].last_seen;
+                return (aTime ?? "").localeCompare(bTime ?? "");
+            });
+            return idle[0][0];
+        }
+        // No idle agents - pick least recently active (might finish soonest)
+        const sorted = [...active].sort((a, b) => {
+            const aTime = a[1].last_activity ?? a[1].last_seen;
+            const bTime = b[1].last_activity ?? b[1].last_seen;
+            return (aTime ?? "").localeCompare(bTime ?? "");
+        });
+        return sorted[0][0];
+    }
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/plan/context.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Build a unified context string combining:
+ * - Last iteration score/feedback from the shared plan
+ * - Active decisions
+ * - File change log
+ */
+export declare function buildContext(cwd: string): Promise<string>;
+//# sourceMappingURL=context.d.ts.map

package/dist/plan/context.js

@@ -0,0 +1,42 @@
+import { getExecutorContext } from "./shared-plan.js";
+import { listDecisions } from "./decisions.js";
+/**
+ * Build a unified context string combining:
+ * - Last iteration score/feedback from the shared plan
+ * - Active decisions
+ * - File change log
+ */
+export async function buildContext(cwd) {
+    const sections = [];
+    // 1. Last iteration context from shared plan
+    const iterationContext = await getExecutorContext(cwd);
+    if (iterationContext) {
+        sections.push(iterationContext);
+    }
+    // 2. Active decisions
+    try {
+        const decisions = await listDecisions(cwd);
+        const active = decisions.filter((d) => d.status === "proposed" || d.status === "accepted");
+        if (active.length > 0) {
+            const decisionLines = [
+                "## Active Decisions",
+                "",
+            ];
+            for (const d of active) {
+                decisionLines.push(`- **[${d.status.toUpperCase()}] #${d.id}: ${d.title}**`);
+                if (d.decision) {
+                    decisionLines.push(`  ${d.decision}`);
+                }
+            }
+            sections.push(decisionLines.join("\n"));
+        }
+    }
+    catch {
+        // No decisions directory — skip
+    }
+    if (sections.length === 0) {
+        return "";
+    }
+    return sections.join("\n\n");
+}
+//# sourceMappingURL=context.js.map

package/dist/plan/decisions.d.ts

@@ -0,0 +1,18 @@
+export interface Decision {
+    id: number;
+    title: string;
+    status: "proposed" | "accepted" | "rejected" | "superseded";
+    context: string;
+    decision: string;
+    consequences: string;
+    date: string;
+}
+type DecisionStatus = Decision["status"];
+/** Add a new decision to the decisions directory. */
+export declare function addDecision(cwd: string, decision: Omit<Decision, "id" | "date">): Promise<Decision>;
+/** List all decisions from the decisions directory. */
+export declare function listDecisions(cwd: string): Promise<Decision[]>;
+/** Resolve (update status of) a decision by ID. */
+export declare function resolveDecision(cwd: string, id: number, status: DecisionStatus): Promise<void>;
+export {};
+//# sourceMappingURL=decisions.d.ts.map

package/dist/plan/decisions.js

@@ -0,0 +1,143 @@
+import { readFileSync, writeFileSync, readdirSync, existsSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import matter from "gray-matter";
+// ── Helpers ─────────────────────────────────────────
+function decisionsDir(cwd) {
+    return join(cwd, ".loop", "context", "decisions");
+}
+function slugify(title) {
+    const cleaned = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-+/g, "-");
+    return cleaned || "decision";
+}
+function nextNumber(dir) {
+    if (!existsSync(dir))
+        return 1;
+    const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+    const numbers = files.map((f) => {
+        const match = f.match(/^(\d{4})-/);
+        return match ? parseInt(match[1], 10) : 0;
+    });
+    return numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
+}
+function padId(id) {
+    return String(id).padStart(4, "0");
+}
+function isValidStatus(s) {
+    return s === "proposed" || s === "accepted" || s === "rejected" || s === "superseded";
+}
+function parseDecisionFile(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const parsed = matter(content);
+        const data = parsed.data;
+        const body = parsed.content;
+        // Extract ID from filename
+        const filename = filePath.split("/").pop() ?? "";
+        const idMatch = filename.match(/^(\d{4})-/);
+        const id = idMatch ? parseInt(idMatch[1], 10) : 0;
+        // Extract title from first heading
+        let title = "";
+        const titleMatch = body.match(/^#\s+(.+)$/m);
+        if (titleMatch) {
+            title = titleMatch[1].replace(/^DECISION\s+\d+:\s*/i, "").trim();
+        }
+        // Extract sections from body
+        const contextMatch = body.match(/Context:\n([\s\S]*?)(?=\nDecision:|\n#|$)/i);
+        const decisionMatch = body.match(/Decision:\n([\s\S]*?)(?=\nConsequences:|\nImplications:|\n#|$)/i);
+        const consequencesMatch = body.match(/(?:Consequences|Implications):\n([\s\S]*?)(?=\n#|$)/i);
+        const status = isValidStatus(data.status) ? data.status : "proposed";
+        const date = typeof data.date === "string"
+            ? data.date
+            : (body.match(/Date:\s*(.+)/)?.[1]?.trim() ?? new Date().toISOString().slice(0, 10));
+        return {
+            id,
+            title: title || (typeof data.title === "string" ? data.title : "(no title)"),
+            status,
+            context: contextMatch?.[1]?.trim() ?? "",
+            decision: decisionMatch?.[1]?.trim() ?? "",
+            consequences: consequencesMatch?.[1]?.trim() ?? "",
+            date,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── Public API ──────────────────────────────────────
+/** Add a new decision to the decisions directory. */
+export async function addDecision(cwd, decision) {
+    const dir = decisionsDir(cwd);
+    mkdirSync(dir, { recursive: true });
+    const id = nextNumber(dir);
+    const date = new Date().toISOString().slice(0, 10);
+    const slug = slugify(decision.title);
+    const filename = `${padId(id)}-${slug}.md`;
+    const filePath = join(dir, filename);
+    // Path traversal guard: ensure file stays within decisions dir
+    if (!resolve(filePath).startsWith(resolve(dir))) {
+        throw new Error("Invalid decision title: path traversal detected");
+    }
+    const content = `---\n` +
+        `status: ${decision.status}\n` +
+        `date: ${date}\n` +
+        `---\n` +
+        `# DECISION ${padId(id)}: ${decision.title}\n\n` +
+        `Date: ${date}\n\n` +
+        `Context:\n${decision.context || "What led to this decision?"}\n\n` +
+        `Decision:\n${decision.decision || "What is now considered true?"}\n\n` +
+        `Consequences:\n${decision.consequences || "What must follow from this?"}\n`;
+    writeFileSync(filePath, content, "utf-8");
+    return {
+        id,
+        title: decision.title,
+        status: decision.status,
+        context: decision.context,
+        decision: decision.decision,
+        consequences: decision.consequences,
+        date,
+    };
+}
+/** List all decisions from the decisions directory. */
+export async function listDecisions(cwd) {
+    const dir = decisionsDir(cwd);
+    if (!existsSync(dir))
+        return [];
+    const files = readdirSync(dir)
+        .filter((f) => f.endsWith(".md"))
+        .sort();
+    const decisions = [];
+    for (const file of files) {
+        const filePath = join(dir, file);
+        const decision = parseDecisionFile(filePath);
+        if (decision) {
+            decisions.push(decision);
+        }
+    }
+    return decisions;
+}
+/** Resolve (update status of) a decision by ID. */
+export async function resolveDecision(cwd, id, status) {
+    const dir = decisionsDir(cwd);
+    if (!existsSync(dir)) {
+        throw new Error(`Decisions directory not found: ${dir}`);
+    }
+    const prefix = padId(id);
+    const files = readdirSync(dir).filter((f) => f.startsWith(prefix) && f.endsWith(".md"));
+    if (files.length === 0) {
+        throw new Error(`Decision ${id} not found`);
+    }
+    const filePath = join(dir, files[0]);
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = matter(content);
+    // Update status in frontmatter
+    const data = parsed.data;
+    data.status = status;
+    data.resolved_at = new Date().toISOString();
+    const updated = matter.stringify(parsed.content, data);
+    writeFileSync(filePath, updated, "utf-8");
+}
+//# sourceMappingURL=decisions.js.map

package/dist/plan/shared-plan.d.ts

@@ -0,0 +1,33 @@
+export interface SharedPlan {
+    task: string;
+    iterations: IterationRecord[];
+    fileChangeLog: FileChange[];
+}
+export interface IterationRecord {
+    iteration: number;
+    executor: string;
+    reviewer: string;
+    score: number;
+    approved: boolean;
+    executorSummary: string;
+    reviewerFeedback: string;
+    timestamp: string;
+}
+export interface FileChange {
+    iteration: number;
+    file: string;
+    action: "created" | "modified" | "deleted";
+}
+/** Initialize a new shared plan file. */
+export declare function initSharedPlan(cwd: string, task: string): Promise<void>;
+/** Update the shared plan with a new iteration record. */
+export declare function updateSharedPlan(cwd: string, record: IterationRecord, filesChanged: string[]): Promise<void>;
+/** Generate a context snippet from the shared plan for the executor prompt. */
+export declare function getExecutorContext(cwd: string): Promise<string>;
+/** Generate a context snippet for the reviewer prompt. */
+export declare function getReviewerContext(cwd: string): Promise<string>;
+/** Clear the shared plan file. */
+export declare function clearPlan(cwd: string): Promise<void>;
+/** Show the raw plan content. */
+export declare function showPlan(cwd: string): Promise<string>;
+//# sourceMappingURL=shared-plan.d.ts.map