@gh-symphony/cli 0.0.14 → 0.0.15

package/dist/commands/logs.js

@@ -1,184 +0,0 @@
-import { readFile, readdir, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
-import { createReadStream } from "node:fs";
-import { createInterface } from "node:readline";
-import { orchestratorLogPath } from "../config.js";
-import { handleMissingManagedProjectConfig, resolveManagedProjectConfig, } from "../project-selection.js";
-function parseLogsArgs(args) {
-    const parsed = { follow: false };
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = args[i];
-        if (arg === "--follow" || arg === "-f") {
-            parsed.follow = true;
-        }
-        if (arg === "--issue") {
-            parsed.issue = args[i + 1];
-            i += 1;
-        }
-        if (arg === "--run") {
-            parsed.run = args[i + 1];
-            i += 1;
-        }
-        if (arg === "--level") {
-            parsed.level = args[i + 1];
-            i += 1;
-        }
-        if (arg === "--project" || arg === "--project-id") {
-            parsed.projectId = args[i + 1];
-            i += 1;
-        }
-    }
-    return parsed;
-}
-const handler = async (args, options) => {
-    const parsed = parseLogsArgs(args);
-    const runtimeRoot = resolve(options.configDir);
-    // If --run is specified, read that run's events
-    if (parsed.run) {
-        const eventsPath = parsed.projectId
-            ? join(runtimeRoot, "projects", parsed.projectId, "runs", parsed.run, "events.ndjson")
-            : await resolveRunEventsPath(runtimeRoot, parsed.run);
-        if (!eventsPath) {
-            process.stderr.write(`No events found for run: ${parsed.run}\n`);
-            process.exitCode = 1;
-            return;
-        }
-        try {
-            const content = await readFile(eventsPath, "utf8");
-            const lines = content.trim().split("\n").filter(Boolean);
-            for (const line of lines) {
-                const event = JSON.parse(line);
-                if (parsed.projectId && event.projectId !== parsed.projectId)
-                    continue;
-                if (parsed.level && event.level !== parsed.level)
-                    continue;
-                if (parsed.issue && event.issueIdentifier !== parsed.issue)
-                    continue;
-                process.stdout.write(formatEvent(event) + "\n");
-            }
-        }
-        catch {
-            process.stderr.write(`No events found for run: ${parsed.run}\n`);
-            process.exitCode = 1;
-        }
-        return;
-    }
-    // Default: read orchestrator log or scan all events
-    if (parsed.follow) {
-        const projectConfig = await resolveManagedProjectConfig({
-            configDir: options.configDir,
-            requestedProjectId: parsed.projectId,
-        });
-        if (!projectConfig) {
-            handleMissingManagedProjectConfig();
-            return;
-        }
-        const logPath = orchestratorLogPath(options.configDir, projectConfig.projectId);
-        try {
-            const stream = createReadStream(logPath, { encoding: "utf8" });
-            const rl = createInterface({ input: stream });
-            for await (const line of rl) {
-                process.stdout.write(line + "\n");
-            }
-            // Follow mode: watch for new lines
-            const { watchFile } = await import("node:fs");
-            let lastSize = 0;
-            watchFile(logPath, { interval: 1000 }, async (curr) => {
-                if (curr.size > lastSize) {
-                    const fd = await import("node:fs/promises");
-                    const handle = await fd.open(logPath, "r");
-                    const buf = Buffer.alloc(curr.size - lastSize);
-                    await handle.read(buf, 0, buf.length, lastSize);
-                    await handle.close();
-                    process.stdout.write(buf.toString("utf8"));
-                    lastSize = curr.size;
-                }
-            });
-            // Keep alive
-            await new Promise(() => { });
-        }
-        catch {
-            process.stderr.write("No log file found. Start the orchestrator first.\n");
-            process.exitCode = 1;
-        }
-        return;
-    }
-    // Scan all run events
-    const runRoots = parsed.projectId
-        ? [join(runtimeRoot, "projects", parsed.projectId, "runs")]
-        : await listProjectRunRoots(runtimeRoot);
-    let foundRuns = false;
-    try {
-        for (const runsDir of runRoots) {
-            const entries = await safeReadDir(runsDir);
-            if (entries.length === 0) {
-                continue;
-            }
-            foundRuns = true;
-            for (const entry of entries) {
-                const eventsPath = join(runsDir, entry, "events.ndjson");
-                try {
-                    const content = await readFile(eventsPath, "utf8");
-                    const lines = content.trim().split("\n").filter(Boolean);
-                    for (const line of lines) {
-                        const event = JSON.parse(line);
-                        if (parsed.projectId && event.projectId !== parsed.projectId)
-                            continue;
-                        if (parsed.level && event.level !== parsed.level)
-                            continue;
-                        if (parsed.issue && event.issueIdentifier !== parsed.issue)
-                            continue;
-                        process.stdout.write(formatEvent(event) + "\n");
-                    }
-                }
-                catch {
-                    // Skip runs without events
-                }
-            }
-        }
-    }
-    catch {
-        // fall through to friendly error below
-    }
-    if (!foundRuns) {
-        process.stderr.write("No runs found. Start the orchestrator first.\n");
-    }
-};
-export default handler;
-function formatEvent(event) {
-    const at = event.at ?? "";
-    const eventType = event.event ?? "unknown";
-    const issue = event.issueIdentifier ?? "";
-    const extra = event.error ? ` error=${event.error}` : "";
-    return `[${at}] ${eventType} ${issue}${extra}`;
-}
-async function listProjectRunRoots(runtimeRoot) {
-    try {
-        const projectIds = await readdir(join(runtimeRoot, "projects"));
-        return projectIds.map((projectId) => join(runtimeRoot, "projects", projectId, "runs"));
-    }
-    catch {
-        return [];
-    }
-}
-async function resolveRunEventsPath(runtimeRoot, runId) {
-    for (const runsDir of await listProjectRunRoots(runtimeRoot)) {
-        const eventsPath = join(runsDir, runId, "events.ndjson");
-        try {
-            await stat(eventsPath);
-            return eventsPath;
-        }
-        catch {
-            // Continue searching.
-        }
-    }
-    return null;
-}
-async function safeReadDir(path) {
-    try {
-        return await readdir(path);
-    }
-    catch {
-        return [];
-    }
-}

package/dist/commands/project.d.ts

@@ -1,3 +0,0 @@
-import type { GlobalOptions } from "../index.js";
-declare const handler: (args: string[], options: GlobalOptions) => Promise<void>;
-export default handler;