awel 0.1.0

package/dist/cli/tools/write.js

@@ -0,0 +1,26 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { writeFileSync, mkdirSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { pushSnapshot } from '../undo.js';
+export function createWriteTool(cwd) {
+    return tool({
+        description: 'Write content to a file. Creates the file and any parent directories if they do not exist. Overwrites existing files.',
+        inputSchema: z.object({
+            file_path: z.string().describe('The path to the file to write (absolute or relative to project root)'),
+            content: z.string().describe('The content to write to the file'),
+        }),
+        execute: async ({ file_path, content }) => {
+            const fullPath = file_path.startsWith('/') ? file_path : resolve(cwd, file_path);
+            try {
+                pushSnapshot(fullPath);
+                mkdirSync(dirname(fullPath), { recursive: true });
+                writeFileSync(fullPath, content, 'utf-8');
+                return `Successfully wrote to ${file_path}`;
+            }
+            catch (err) {
+                return `Error writing file: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+}

package/dist/cli/types.d.ts

@@ -0,0 +1,16 @@
+export interface SelectedElement {
+    tag: string;
+    component: string | null;
+    source: string | null;
+    text: string;
+    className: string;
+    line: number | null;
+    column: number | null;
+    props: Record<string, string> | null;
+    componentChain: string[] | null;
+    attributes: Record<string, string> | null;
+    comment?: string;
+    mode?: 'attach';
+    sourceSnippet?: string | null;
+    propsTypeDefinition?: string | null;
+}

package/dist/cli/types.js

@@ -0,0 +1,2 @@
+// ─── Inspector Types ─────────────────────────────────────────
+export {};

package/dist/cli/undo.d.ts

@@ -0,0 +1,49 @@
+import { Hono } from 'hono';
+/**
+ * Starts a new undo session. All file snapshots captured after this call
+ * (and before endUndoSession) will be grouped together.
+ * @returns The new session ID
+ */
+export declare function startUndoSession(): string;
+/**
+ * Ends the current undo session. If snapshots were captured, the session
+ * is added to the session stack for later undo. Otherwise, the empty session is discarded.
+ */
+export declare function endUndoSession(): void;
+/**
+ * Captures the current content of a file before it's modified.
+ * For new files (that don't exist yet), stores empty string so undo can delete them.
+ * Only captures if there's an active session.
+ */
+export declare function pushSnapshot(filePath: string): void;
+/**
+ * Pops the most recent session and restores all files to their previous states.
+ * If a snapshot content is empty and the file was newly created, deletes it.
+ * @returns Array of restored file paths, or null if nothing to undo
+ */
+export declare function popAndRestoreSession(): string[] | null;
+/**
+ * Reads the most recent session from the stack (without popping it) and pairs
+ * each snapshot's original content with the current file content on disk.
+ */
+export declare function getLatestSessionDiffs(projectCwd: string): {
+    relativePath: string;
+    originalContent: string;
+    currentContent: string;
+    existed: boolean;
+    existsNow: boolean;
+}[] | null;
+/**
+ * Returns lightweight stats for the currently active (not yet ended) session.
+ * Call this before endUndoSession() to include stats in the result event.
+ */
+export declare function getCurrentSessionStats(projectCwd: string): {
+    relativePath: string;
+    additions: number;
+    deletions: number;
+    isNew: boolean;
+}[] | null;
+/**
+ * Creates Hono routes for the undo API.
+ */
+export declare function createUndoRoute(projectCwd: string): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/cli/undo.js

@@ -0,0 +1,212 @@
+import { Hono } from 'hono';
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { relative } from 'path';
+/**
+ * Session-based undo groups.
+ * Each session ID maps to a list of file snapshots made during that session.
+ */
+const undoGroups = new Map();
+/**
+ * Stack of session IDs in LIFO order for undo operations.
+ */
+const sessionStack = [];
+/**
+ * The currently active session ID. Snapshots are only captured when a session is active.
+ */
+let currentSessionId = null;
+/**
+ * Generates a unique session ID.
+ */
+function generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+ * Starts a new undo session. All file snapshots captured after this call
+ * (and before endUndoSession) will be grouped together.
+ * @returns The new session ID
+ */
+export function startUndoSession() {
+    const sessionId = generateSessionId();
+    currentSessionId = sessionId;
+    undoGroups.set(sessionId, []);
+    return sessionId;
+}
+/**
+ * Ends the current undo session. If snapshots were captured, the session
+ * is added to the session stack for later undo. Otherwise, the empty session is discarded.
+ */
+export function endUndoSession() {
+    if (currentSessionId) {
+        const snapshots = undoGroups.get(currentSessionId);
+        if (snapshots && snapshots.length > 0) {
+            sessionStack.push(currentSessionId);
+        }
+        else {
+            // No snapshots captured, discard empty session
+            undoGroups.delete(currentSessionId);
+        }
+    }
+    currentSessionId = null;
+}
+/**
+ * Captures the current content of a file before it's modified.
+ * For new files (that don't exist yet), stores empty string so undo can delete them.
+ * Only captures if there's an active session.
+ */
+export function pushSnapshot(filePath) {
+    if (!currentSessionId) {
+        // No active session, skip snapshot
+        return;
+    }
+    const snapshots = undoGroups.get(currentSessionId);
+    if (!snapshots) {
+        return;
+    }
+    // Check if we already have a snapshot for this file in this session
+    // (we only want to capture the original state, not intermediate states)
+    const alreadySnapshotted = snapshots.some(s => s.filePath === filePath);
+    if (alreadySnapshotted) {
+        return;
+    }
+    const existed = existsSync(filePath);
+    const content = existed ? readFileSync(filePath, 'utf-8') : '';
+    snapshots.push({ filePath, content, timestamp: Date.now(), existed });
+}
+/**
+ * Pops the most recent session and restores all files to their previous states.
+ * If a snapshot content is empty and the file was newly created, deletes it.
+ * @returns Array of restored file paths, or null if nothing to undo
+ */
+export function popAndRestoreSession() {
+    const sessionId = sessionStack.pop();
+    if (!sessionId)
+        return null;
+    const snapshots = undoGroups.get(sessionId);
+    if (!snapshots || snapshots.length === 0) {
+        undoGroups.delete(sessionId);
+        return null;
+    }
+    const restoredPaths = [];
+    // Restore in reverse order (last modified first)
+    for (let i = snapshots.length - 1; i >= 0; i--) {
+        const snapshot = snapshots[i];
+        try {
+            if (!snapshot.existed && existsSync(snapshot.filePath)) {
+                // File was newly created — undo means delete it
+                unlinkSync(snapshot.filePath);
+            }
+            else {
+                writeFileSync(snapshot.filePath, snapshot.content, 'utf-8');
+            }
+            restoredPaths.push(snapshot.filePath);
+        }
+        catch (err) {
+            console.error(`Failed to restore ${snapshot.filePath}:`, err);
+        }
+    }
+    undoGroups.delete(sessionId);
+    return restoredPaths;
+}
+/**
+ * Reads the most recent session from the stack (without popping it) and pairs
+ * each snapshot's original content with the current file content on disk.
+ */
+export function getLatestSessionDiffs(projectCwd) {
+    if (sessionStack.length === 0)
+        return null;
+    const sessionId = sessionStack[sessionStack.length - 1];
+    const snapshots = undoGroups.get(sessionId);
+    if (!snapshots || snapshots.length === 0)
+        return null;
+    return snapshots.map((snapshot) => {
+        const relativePath = relative(projectCwd, snapshot.filePath);
+        const existsNow = existsSync(snapshot.filePath);
+        const currentContent = existsNow ? readFileSync(snapshot.filePath, 'utf-8') : '';
+        return {
+            relativePath,
+            originalContent: snapshot.content,
+            currentContent,
+            existed: snapshot.existed,
+            existsNow,
+        };
+    });
+}
+/**
+ * Computes +/- line stats for two strings using bag-based line matching.
+ */
+function countLineStats(original, current) {
+    const oldLines = original.split('\n');
+    const newLines = current.split('\n');
+    const oldBag = new Map();
+    for (const line of oldLines) {
+        oldBag.set(line, (oldBag.get(line) || 0) + 1);
+    }
+    let matched = 0;
+    for (const line of newLines) {
+        const count = oldBag.get(line);
+        if (count && count > 0) {
+            oldBag.set(line, count - 1);
+            matched++;
+        }
+    }
+    return {
+        additions: newLines.length - matched,
+        deletions: oldLines.length - matched,
+    };
+}
+/**
+ * Returns lightweight stats for the currently active (not yet ended) session.
+ * Call this before endUndoSession() to include stats in the result event.
+ */
+export function getCurrentSessionStats(projectCwd) {
+    if (!currentSessionId)
+        return null;
+    const snapshots = undoGroups.get(currentSessionId);
+    if (!snapshots || snapshots.length === 0)
+        return null;
+    return snapshots.map((snapshot) => {
+        const relativePath = relative(projectCwd, snapshot.filePath);
+        const existsNow = existsSync(snapshot.filePath);
+        const currentContent = existsNow ? readFileSync(snapshot.filePath, 'utf-8') : '';
+        const isNew = !snapshot.existed && existsNow;
+        const { additions, deletions } = countLineStats(snapshot.content, currentContent);
+        return { relativePath, additions, deletions, isNew };
+    });
+}
+/**
+ * Creates Hono routes for the undo API.
+ */
+export function createUndoRoute(projectCwd) {
+    const undo = new Hono();
+    undo.post('/api/undo', async (c) => {
+        const restoredPaths = popAndRestoreSession();
+        if (restoredPaths && restoredPaths.length > 0) {
+            return c.json({
+                success: true,
+                restored: restoredPaths.map(p => relative(projectCwd, p)),
+            });
+        }
+        return c.json({ success: false, error: 'Nothing to undo' }, 400);
+    });
+    undo.get('/api/undo/diff', async (c) => {
+        const diffs = getLatestSessionDiffs(projectCwd);
+        if (!diffs) {
+            return c.json({ success: false, error: 'No session to diff' }, 400);
+        }
+        return c.json({ success: true, diffs });
+    });
+    undo.get('/api/undo/stack', async (c) => {
+        const sessions = sessionStack.map(sessionId => {
+            const snapshots = undoGroups.get(sessionId) || [];
+            return {
+                sessionId,
+                files: snapshots.map(s => ({
+                    file: relative(projectCwd, s.filePath),
+                    timestamp: s.timestamp,
+                })),
+            };
+        });
+        return c.json(sessions);
+    });
+    return undo;
+}

package/dist/cli/verbose.d.ts

@@ -0,0 +1,7 @@
+export declare function setVerbose(enabled: boolean): void;
+export declare function isVerbose(): boolean;
+/**
+ * Log a verbose event to the terminal. No-op if verbose mode is off.
+ * Outputs human-readable, color-coded lines to stderr.
+ */
+export declare function logEvent(eventType: string, detail?: string): void;

package/dist/cli/verbose.js

@@ -0,0 +1,60 @@
+// ─── Verbose Mode ────────────────────────────────────────────
+// Module-level toggle for CLI verbose logging.
+let _verbose = false;
+export function setVerbose(enabled) {
+    _verbose = enabled;
+}
+export function isVerbose() {
+    return _verbose;
+}
+// ANSI 256-color helpers — darker shades that stay visible on light backgrounds
+const dim = (s) => `\x1b[2m${s}\x1b[22m`;
+const cyan = (s) => `\x1b[38;5;30m${s}\x1b[39m`;
+const yellow = (s) => `\x1b[38;5;136m${s}\x1b[39m`;
+const green = (s) => `\x1b[38;5;34m${s}\x1b[39m`;
+const red = (s) => `\x1b[38;5;160m${s}\x1b[39m`;
+const magenta = (s) => `\x1b[38;5;127m${s}\x1b[39m`;
+const bold = (s) => `\x1b[1m${s}\x1b[22m`;
+function timestamp() {
+    const now = new Date();
+    const h = String(now.getHours()).padStart(2, '0');
+    const m = String(now.getMinutes()).padStart(2, '0');
+    const s = String(now.getSeconds()).padStart(2, '0');
+    const ms = String(now.getMilliseconds()).padStart(3, '0');
+    return dim(`[${h}:${m}:${s}.${ms}]`);
+}
+function truncate(s, max = 120) {
+    const oneLine = s.replace(/\n/g, '\\n');
+    if (oneLine.length <= max)
+        return oneLine;
+    return oneLine.slice(0, max) + dim('…');
+}
+function colorForEvent(eventType) {
+    if (eventType.startsWith('stream:'))
+        return cyan;
+    switch (eventType) {
+        case 'text-delta': return dim;
+        case 'tool-call': return yellow;
+        case 'tool-result': return green;
+        case 'plan': return magenta;
+        case 'question': return magenta;
+        case 'finish-step': return dim;
+        case 'error': return red;
+        case 'abort': return red;
+        default: return (s) => s;
+    }
+}
+/**
+ * Log a verbose event to the terminal. No-op if verbose mode is off.
+ * Outputs human-readable, color-coded lines to stderr.
+ */
+export function logEvent(eventType, detail) {
+    if (!_verbose)
+        return;
+    const color = colorForEvent(eventType);
+    const tag = color(bold(eventType.padEnd(14)));
+    const parts = [timestamp(), tag];
+    if (detail)
+        parts.push(truncate(detail, 200));
+    process.stderr.write(parts.join(' ') + '\n');
+}