@lawrence369/loop-cli 0.1.0

package/dist/plan/shared-plan.js

@@ -0,0 +1,211 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+const SHARED_PLAN_FILENAME = ".loop-plan.md";
+// ── Helpers ─────────────────────────────────────────
+function getPlanPath(cwd) {
+    return join(cwd, SHARED_PLAN_FILENAME);
+}
+function readPlan(cwd) {
+    const path = getPlanPath(cwd);
+    if (!existsSync(path))
+        return null;
+    try {
+        const content = readFileSync(path, "utf-8");
+        return parsePlan(content);
+    }
+    catch {
+        return null;
+    }
+}
+function writePlanSafe(cwd, content) {
+    try {
+        writeFileSync(getPlanPath(cwd), content, "utf-8");
+    }
+    catch {
+        // Fail-silent: never crash on write errors
+    }
+}
+// ── Public API ──────────────────────────────────────
+/** Initialize a new shared plan file. */
+export async function initSharedPlan(cwd, task) {
+    const content = renderPlan({
+        task,
+        iterations: [],
+        fileChangeLog: [],
+    });
+    writePlanSafe(cwd, content);
+}
+/** Update the shared plan with a new iteration record. */
+export async function updateSharedPlan(cwd, record, filesChanged) {
+    const plan = readPlan(cwd) ?? {
+        task: "",
+        iterations: [],
+        fileChangeLog: [],
+    };
+    plan.iterations.push(record);
+    for (const file of filesChanged) {
+        plan.fileChangeLog.push({
+            iteration: record.iteration,
+            file,
+            action: "modified",
+        });
+    }
+    writePlanSafe(cwd, renderPlan(plan));
+}
+/** Generate a context snippet from the shared plan for the executor prompt. */
+export async function getExecutorContext(cwd) {
+    const plan = readPlan(cwd);
+    if (!plan || plan.iterations.length === 0)
+        return "";
+    const lastIter = plan.iterations[plan.iterations.length - 1];
+    const lines = [
+        "## Previous Iteration Context (from shared plan)",
+        "",
+        `Last iteration: ${lastIter.iteration}`,
+        `Reviewer score: ${lastIter.score}/10`,
+        `Approved: ${lastIter.approved ? "Yes" : "No"}`,
+        "",
+        "Recent feedback:",
+        lastIter.reviewerFeedback,
+    ];
+    if (plan.fileChangeLog.length > 0) {
+        lines.push("");
+        lines.push("Files changed so far:");
+        for (const change of plan.fileChangeLog) {
+            lines.push(`- ${change.file} (${change.action}, iteration ${change.iteration})`);
+        }
+    }
+    return lines.join("\n");
+}
+/** Generate a context snippet for the reviewer prompt. */
+export async function getReviewerContext(cwd) {
+    const plan = readPlan(cwd);
+    if (!plan || plan.iterations.length === 0)
+        return "";
+    const lines = [
+        "## Iteration History (from shared plan)",
+        "",
+    ];
+    for (const iter of plan.iterations) {
+        lines.push(`### Iteration ${iter.iteration}: Score ${iter.score}/10 (${iter.approved ? "Approved" : "Not approved"})`);
+        lines.push(`Key feedback: ${iter.reviewerFeedback.split("\n")[0]}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/** Clear the shared plan file. */
+export async function clearPlan(cwd) {
+    try {
+        const path = getPlanPath(cwd);
+        if (existsSync(path)) {
+            const { unlinkSync } = await import("node:fs");
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // Fail-silent
+    }
+}
+/** Show the raw plan content. */
+export async function showPlan(cwd) {
+    const path = getPlanPath(cwd);
+    if (!existsSync(path))
+        return "No plan file found.";
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return "Error reading plan file.";
+    }
+}
+// ── Rendering ───────────────────────────────────────
+function renderPlan(plan) {
+    const sections = [];
+    sections.push("# Loop Shared Plan");
+    sections.push("");
+    sections.push("## Task");
+    sections.push(plan.task);
+    sections.push("");
+    sections.push("## Iteration History");
+    sections.push("");
+    if (plan.iterations.length === 0) {
+        sections.push("_No iterations yet._");
+    }
+    else {
+        for (const iter of plan.iterations) {
+            sections.push(`### Iteration ${iter.iteration}`);
+            sections.push(`- **Timestamp:** ${iter.timestamp}`);
+            sections.push(`- **Executor:** ${iter.executor}`);
+            sections.push(`- **Reviewer:** ${iter.reviewer}`);
+            sections.push(`- **Score:** ${iter.score}/10`);
+            sections.push(`- **Approved:** ${iter.approved ? "Yes" : "No"}`);
+            sections.push("");
+            sections.push("**Executor Summary:**");
+            sections.push(iter.executorSummary);
+            sections.push("");
+            sections.push("**Reviewer Feedback:**");
+            sections.push(iter.reviewerFeedback);
+            sections.push("");
+        }
+    }
+    sections.push("## File Change Log");
+    sections.push("");
+    if (plan.fileChangeLog.length === 0) {
+        sections.push("_No file changes recorded._");
+    }
+    else {
+        for (const change of plan.fileChangeLog) {
+            sections.push(`- [Iteration ${change.iteration}] ${change.action}: ${change.file}`);
+        }
+    }
+    sections.push("");
+    return sections.join("\n");
+}
+// ── Parsing ─────────────────────────────────────────
+function parsePlan(content) {
+    const plan = {
+        task: "",
+        iterations: [],
+        fileChangeLog: [],
+    };
+    // Extract task
+    const taskMatch = content.match(/## Task\n([\s\S]*?)(?=\n## )/);
+    if (taskMatch)
+        plan.task = taskMatch[1].trim();
+    // Extract iteration records
+    const iterPattern = /### Iteration (\d+)\n([\s\S]*?)(?=\n### Iteration |\n## |$)/g;
+    let iterMatch;
+    while ((iterMatch = iterPattern.exec(content)) !== null) {
+        const num = parseInt(iterMatch[1], 10);
+        const body = iterMatch[2];
+        const scoreMatch = body.match(/\*\*Score:\*\*\s*(\d+)/);
+        const approvedMatch = body.match(/\*\*Approved:\*\*\s*(Yes|No)/i);
+        const executorMatch = body.match(/\*\*Executor:\*\*\s*(\w+)/);
+        const reviewerMatch = body.match(/\*\*Reviewer:\*\*\s*(\w+)/);
+        const timestampMatch = body.match(/\*\*Timestamp:\*\*\s*(.+)/);
+        const summaryMatch = body.match(/\*\*Executor Summary:\*\*\n([\s\S]*?)(?=\n\*\*Reviewer Feedback:\*\*|$)/);
+        const feedbackMatch = body.match(/\*\*Reviewer Feedback:\*\*\n([\s\S]*?)$/);
+        plan.iterations.push({
+            iteration: num,
+            timestamp: timestampMatch?.[1]?.trim() ?? "",
+            executor: executorMatch?.[1] ?? "",
+            reviewer: reviewerMatch?.[1] ?? "",
+            executorSummary: summaryMatch?.[1]?.trim() ?? "",
+            score: scoreMatch ? parseInt(scoreMatch[1], 10) : 0,
+            approved: approvedMatch?.[1]?.toLowerCase() === "yes",
+            reviewerFeedback: feedbackMatch?.[1]?.trim() ?? "",
+        });
+    }
+    // Extract file change log
+    const changePattern = /- \[Iteration (\d+)\] (created|modified|deleted): (.+)/g;
+    let changeMatch;
+    while ((changeMatch = changePattern.exec(content)) !== null) {
+        plan.fileChangeLog.push({
+            iteration: parseInt(changeMatch[1], 10),
+            file: changeMatch[3].trim(),
+            action: changeMatch[2],
+        });
+    }
+    return plan;
+}
+//# sourceMappingURL=shared-plan.js.map

package/dist/skills/executor.d.ts

@@ -0,0 +1,7 @@
+import { type Skill } from "./loader.js";
+/**
+ * Inject skill content into a prompt.
+ * Each skill is wrapped with delimiters for clarity.
+ */
+export declare function injectSkills(prompt: string, skills: Skill[]): string;
+//# sourceMappingURL=executor.d.ts.map

package/dist/skills/executor.js

@@ -0,0 +1,11 @@
+/**
+ * Inject skill content into a prompt.
+ * Each skill is wrapped with delimiters for clarity.
+ */
+export function injectSkills(prompt, skills) {
+    if (skills.length === 0)
+        return prompt;
+    const skillBlocks = skills.map((skill) => `--- SKILL: ${skill.name} ---\n${skill.content}\n--- END SKILL ---`);
+    return skillBlocks.join("\n\n") + "\n\n" + prompt;
+}
+//# sourceMappingURL=executor.js.map

package/dist/skills/loader.d.ts

@@ -0,0 +1,16 @@
+export interface Skill {
+    name: string;
+    description: string;
+    content: string;
+    path: string;
+    scope: "global" | "project" | "builtin";
+}
+/**
+ * Discover skills from multiple locations.
+ * Search order (later scopes override earlier on name collision):
+ * 1. Built-in: <packageRoot>/skills/<name>/SKILL.md
+ * 2. Global:   ~/.loop/skills/<name>/SKILL.md
+ * 3. Project:  <cwd>/SKILLS/<name>/SKILL.md
+ */
+export declare function discoverSkills(cwd: string): Promise<Skill[]>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/skills/loader.js

@@ -0,0 +1,80 @@
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import matter from "gray-matter";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = join(__dirname, "..", "..");
+function readSkillFile(skillDir, scope) {
+    const skillPath = join(skillDir, "SKILL.md");
+    if (!existsSync(skillPath))
+        return null;
+    try {
+        const raw = readFileSync(skillPath, "utf-8");
+        const parsed = matter(raw);
+        const data = parsed.data;
+        const name = typeof data.name === "string" && data.name
+            ? data.name
+            : skillDir.split("/").pop() ?? "unknown";
+        const description = typeof data.description === "string"
+            ? data.description.trim()
+            : "";
+        return {
+            name,
+            description,
+            content: parsed.content.trim(),
+            path: skillPath,
+            scope,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function discoverFromDir(baseDir, scope) {
+    if (!existsSync(baseDir))
+        return [];
+    const skills = [];
+    try {
+        const entries = readdirSync(baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skill = readSkillFile(join(baseDir, entry.name), scope);
+                if (skill) {
+                    skills.push(skill);
+                }
+            }
+        }
+    }
+    catch {
+        // Directory not readable — skip
+    }
+    return skills;
+}
+/**
+ * Discover skills from multiple locations.
+ * Search order (later scopes override earlier on name collision):
+ * 1. Built-in: <packageRoot>/skills/<name>/SKILL.md
+ * 2. Global:   ~/.loop/skills/<name>/SKILL.md
+ * 3. Project:  <cwd>/SKILLS/<name>/SKILL.md
+ */
+export async function discoverSkills(cwd) {
+    const seen = new Map();
+    // 1. Built-in skills
+    const builtinDir = join(PACKAGE_ROOT, "skills");
+    for (const skill of discoverFromDir(builtinDir, "builtin")) {
+        seen.set(skill.name, skill);
+    }
+    // 2. Global skills (~/.loop/skills/)
+    const globalDir = join(homedir(), ".loop", "skills");
+    for (const skill of discoverFromDir(globalDir, "global")) {
+        seen.set(skill.name, skill);
+    }
+    // 3. Project skills (<cwd>/SKILLS/)
+    const projectDir = join(cwd, "SKILLS");
+    for (const skill of discoverFromDir(projectDir, "project")) {
+        seen.set(skill.name, skill);
+    }
+    return Array.from(seen.values());
+}
+//# sourceMappingURL=loader.js.map

package/dist/skills/registry.d.ts

@@ -0,0 +1,13 @@
+import { type Skill } from "./loader.js";
+export declare class SkillRegistry {
+    private skills;
+    /** Load/reload all discoverable skills. */
+    load(cwd: string): Promise<void>;
+    /** Get a single skill by name. */
+    get(name: string): Skill | undefined;
+    /** List all loaded skills. */
+    list(): Skill[];
+    /** Add a new skill (write SKILL.md to disk). */
+    add(name: string, content: string, scope: "global" | "project", cwd?: string): Promise<void>;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/skills/registry.js

@@ -0,0 +1,54 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { discoverSkills } from "./loader.js";
+export class SkillRegistry {
+    skills = new Map();
+    /** Load/reload all discoverable skills. */
+    async load(cwd) {
+        this.skills.clear();
+        const discovered = await discoverSkills(cwd);
+        for (const skill of discovered) {
+            this.skills.set(skill.name, skill);
+        }
+    }
+    /** Get a single skill by name. */
+    get(name) {
+        return this.skills.get(name);
+    }
+    /** List all loaded skills. */
+    list() {
+        return Array.from(this.skills.values());
+    }
+    /** Add a new skill (write SKILL.md to disk). */
+    async add(name, content, scope, cwd) {
+        // Prevent path traversal
+        if (/[/\\]|^\.\.?$/.test(name) || name.includes("..")) {
+            throw new Error(`Invalid skill name: ${name}`);
+        }
+        let baseDir;
+        if (scope === "global") {
+            baseDir = join(homedir(), ".loop", "skills");
+        }
+        else {
+            if (!cwd) {
+                throw new Error("cwd is required when adding a project-scoped skill");
+            }
+            baseDir = join(cwd, "SKILLS");
+        }
+        const skillDir = join(baseDir, name);
+        mkdirSync(skillDir, { recursive: true });
+        const skillPath = join(skillDir, "SKILL.md");
+        const fileContent = `---\nname: ${name}\ndescription: ""\n---\n\n${content}\n`;
+        writeFileSync(skillPath, fileContent, "utf-8");
+        // Register in memory
+        this.skills.set(name, {
+            name,
+            description: "",
+            content,
+            path: skillPath,
+            scope,
+        });
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/terminal/adapter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Terminal adapter interface and factory.
+ *
+ * Each adapter wraps a specific terminal environment (Terminal.app, tmux,
+ * iTerm2, internal PTY) behind a common interface so the agent launcher
+ * can spawn and manage processes uniformly.
+ *
+ * Ported from ufoo's adapterRouter.js / adapterContract.js with simplified
+ * TypeScript interfaces.
+ */
+import type { LaunchMode } from "./detect.js";
+export interface TerminalCapabilities {
+    /** Can bring the terminal window / pane to the foreground. */
+    supportsActivate: boolean;
+    /** Can inject text into a running process via send-keys or socket. */
+    supportsInjection: boolean;
+    /** Supports reusing a previous session in the same terminal / pane. */
+    supportsSessionReuse: boolean;
+    /** Can programmatically resize the PTY. */
+    supportsResize: boolean;
+}
+export interface AdapterLaunchOptions {
+    cwd: string;
+    env?: Record<string, string>;
+    cols?: number;
+    rows?: number;
+}
+export interface LaunchedProcess {
+    pid: number;
+    write(data: string): void;
+    resize(cols: number, rows: number): void;
+    kill(): void;
+    onData(handler: (data: string) => void): void;
+    onExit(handler: (code: number) => void): void;
+}
+export interface TerminalAdapter {
+    mode: LaunchMode;
+    capabilities: TerminalCapabilities;
+    /**
+     * Spawn a new process inside this terminal environment.
+     */
+    launch(command: string, args: string[], opts: AdapterLaunchOptions): Promise<LaunchedProcess>;
+    /**
+     * Inject text into a running process (e.g. tmux send-keys).
+     * Only available when `capabilities.supportsInjection` is true.
+     */
+    inject?(processOrId: number | string, command: string): Promise<void>;
+    /**
+     * Bring the terminal window / pane to the foreground.
+     * Only available when `capabilities.supportsActivate` is true.
+     */
+    activate?(processOrId: number | string): Promise<void>;
+}
+/**
+ * Create the appropriate terminal adapter for the given launch mode.
+ *
+ * Adapters are lazily imported to avoid loading unnecessary platform-specific
+ * code (e.g. osascript helpers on Linux).
+ */
+export declare function createAdapter(mode: LaunchMode): Promise<TerminalAdapter>;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/terminal/adapter.js

@@ -0,0 +1,42 @@
+/**
+ * Terminal adapter interface and factory.
+ *
+ * Each adapter wraps a specific terminal environment (Terminal.app, tmux,
+ * iTerm2, internal PTY) behind a common interface so the agent launcher
+ * can spawn and manage processes uniformly.
+ *
+ * Ported from ufoo's adapterRouter.js / adapterContract.js with simplified
+ * TypeScript interfaces.
+ */
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the appropriate terminal adapter for the given launch mode.
+ *
+ * Adapters are lazily imported to avoid loading unnecessary platform-specific
+ * code (e.g. osascript helpers on Linux).
+ */
+export async function createAdapter(mode) {
+    switch (mode) {
+        case "terminal": {
+            const { NativeTerminalAdapter } = await import("./terminal-adapter.js");
+            return new NativeTerminalAdapter();
+        }
+        case "tmux": {
+            const { TmuxAdapter } = await import("./tmux-adapter.js");
+            return new TmuxAdapter();
+        }
+        case "iterm2": {
+            const { ITerm2Adapter } = await import("./iterm2-adapter.js");
+            return new ITerm2Adapter();
+        }
+        case "pty":
+        case "auto":
+        default: {
+            const { PtyAdapter } = await import("./pty-adapter.js");
+            return new PtyAdapter();
+        }
+    }
+}
+//# sourceMappingURL=adapter.js.map

package/dist/terminal/detect.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Terminal environment detection.
+ *
+ * Identifies the terminal emulator (iTerm2, tmux, Terminal.app, etc.)
+ * and resolves a launch mode for agent spawning.
+ *
+ * Ported from ufoo's terminal/detect.js and launcher.js `resolveLaunchMode`.
+ */
+export type LaunchMode = "terminal" | "tmux" | "iterm2" | "pty" | "auto";
+/**
+ * Detect the appropriate launch mode based on environment variables.
+ *
+ * Priority:
+ *  1. LOOP_LAUNCH_MODE env override (explicit user choice)
+ *  2. TMUX_PANE present → "tmux"
+ *  3. ITERM_SESSION_ID present → "iterm2"
+ *  4. Fallback → "pty" (headless internal PTY)
+ */
+export declare function detectTerminal(): LaunchMode;
+/**
+ * Detect the TTY device path for the current process.
+ * Returns `undefined` when running without a controlling terminal.
+ */
+export declare function detectTTY(): string | undefined;
+/**
+ * Return the current tmux pane identifier (e.g. `%0`, `%1`).
+ * Returns `undefined` when not inside a tmux session.
+ */
+export declare function detectTmuxPane(): string | undefined;
+//# sourceMappingURL=detect.d.ts.map

package/dist/terminal/detect.js

@@ -0,0 +1,77 @@
+/**
+ * Terminal environment detection.
+ *
+ * Identifies the terminal emulator (iTerm2, tmux, Terminal.app, etc.)
+ * and resolves a launch mode for agent spawning.
+ *
+ * Ported from ufoo's terminal/detect.js and launcher.js `resolveLaunchMode`.
+ */
+import { spawnSync } from "node:child_process";
+// ---------------------------------------------------------------------------
+// Terminal detection
+// ---------------------------------------------------------------------------
+/**
+ * Detect the appropriate launch mode based on environment variables.
+ *
+ * Priority:
+ *  1. LOOP_LAUNCH_MODE env override (explicit user choice)
+ *  2. TMUX_PANE present → "tmux"
+ *  3. ITERM_SESSION_ID present → "iterm2"
+ *  4. Fallback → "pty" (headless internal PTY)
+ */
+export function detectTerminal() {
+    const explicit = (process.env.LOOP_LAUNCH_MODE ?? "").trim().toLowerCase();
+    if (explicit === "terminal" || explicit === "tmux" || explicit === "iterm2" || explicit === "pty") {
+        return explicit;
+    }
+    if (process.env.TMUX_PANE)
+        return "tmux";
+    if (process.env.ITERM_SESSION_ID)
+        return "iterm2";
+    return "pty";
+}
+// ---------------------------------------------------------------------------
+// TTY detection
+// ---------------------------------------------------------------------------
+function normalizeTty(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed === "not a tty" || trimmed === "/dev/tty") {
+        return undefined;
+    }
+    return trimmed;
+}
+/**
+ * Detect the TTY device path for the current process.
+ * Returns `undefined` when running without a controlling terminal.
+ */
+export function detectTTY() {
+    // Allow explicit override for test / sandbox environments
+    const override = normalizeTty(process.env.LOOP_TTY_OVERRIDE ?? "");
+    if (override)
+        return override;
+    try {
+        const result = spawnSync("tty", {
+            stdio: [0, "pipe", "ignore"],
+            encoding: "utf8",
+        });
+        if (result.status === 0 && result.stdout) {
+            return normalizeTty(result.stdout);
+        }
+    }
+    catch {
+        // tty command unavailable or failed — not fatal
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// tmux pane detection
+// ---------------------------------------------------------------------------
+/**
+ * Return the current tmux pane identifier (e.g. `%0`, `%1`).
+ * Returns `undefined` when not inside a tmux session.
+ */
+export function detectTmuxPane() {
+    const pane = process.env.TMUX_PANE;
+    return pane ? pane.trim() || undefined : undefined;
+}
+//# sourceMappingURL=detect.js.map

package/dist/terminal/iterm2-adapter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * iTerm2 adapter.
+ *
+ * Uses osascript with iTerm2's AppleScript API to create new sessions
+ * (tabs / splits) and run commands.  Supports activation (bring to front)
+ * and text injection via `write text`.
+ *
+ * Reference: https://iterm2.com/documentation-scripting.html
+ */
+import type { AdapterLaunchOptions, LaunchedProcess, TerminalAdapter, TerminalCapabilities } from "./adapter.js";
+import type { LaunchMode } from "./detect.js";
+export declare class ITerm2Adapter implements TerminalAdapter {
+    readonly mode: LaunchMode;
+    readonly capabilities: TerminalCapabilities;
+    launch(command: string, args: string[], opts: AdapterLaunchOptions): Promise<LaunchedProcess>;
+    inject(processOrId: number | string, command: string): Promise<void>;
+    activate(_processOrId: number | string): Promise<void>;
+}
+//# sourceMappingURL=iterm2-adapter.d.ts.map