@rse/ase 1.0.7 → 2.0.1

package/dst/ase-spec.js

@@ -8,16 +8,23 @@ import fs from "node:fs";
 import { isScalar } from "yaml";
 import { z } from "zod";
 import sourceCodeError from "source-code-error";
-import { SpecBook, renderDiagnostic, renderVerbose, formats, parseOutputSpec, previewAddr, previewPort } from "@rse/specbook";
-import { Config, configSchema } from "./ase-config.js";
+import { renderDiagnostic } from "@rse/specbook/dst/specbook-diagnostic.js";
+import { renderVerbose } from "@rse/specbook/dst/specbook-verbose.js";
+import { Config } from "./ase-config-core.js";
+import { configSchema } from "./ase-config-schema.js";
 import { Task } from "./ase-task.js";
 import { Artifact } from "./ase-artifact.js";
-import { Meta } from "./ase-meta.js";
-import { writeStdout } from "./ase-stdio.js";
+import { Meta } from "./ase-util-meta.js";
+import { writeStdout } from "./ase-lib-stdio.js";
 /*  reusable functionality: lint, export, and preview the SpecBook-based
     project specification, located via the "project.artifact.spec.basedir"
     and "project.artifact.spec.schema" configuration  */
 export class Spec {
+    /*  the SpecBook export formats, mirrored here (and checked for completeness
+        against SpecBook at compile-time) to not load SpecBook for the MCP schema  */
+    static formats = Object.keys({
+        json: true, json5: true, yaml: true, toon: true, html: true, pdf: true, md: true
+    });
     /*  resolve the YAML schema configuration files: the whitespace-separated
         entries of the configured "project.artifact.spec.schema", merged in
         the given order, where each entry is either the literal "std" for the
@@ -51,8 +58,10 @@ export class Spec {
     /*  create the SpecBook API instance, routing its verbose processing
         messages into the log according to their verbosity level, while
         its "none" level messages, for consumers which never see the log,
-        additionally reach the given collector  */
-    static api(log, notices) {
+        additionally reach the given collector
+        (SpecBook itself is loaded on first use only)  */
+    static async api(log, notices) {
+        const { SpecBook } = await import("@rse/specbook");
         return new SpecBook({
             verbose: (cmd, msg, level) => {
                 const text = renderVerbose(msg);
@@ -93,11 +102,11 @@ export class Spec {
     /*  lint the specification Markdown files below the "spec" artifact
         base directory against the schema configuration  */
     static async lint(log) {
-        const result = await Spec.unmarked(Spec.api(log).lint({
+        const result = await Spec.unmarked(Spec.api(log).then((api) => api.lint({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
             gitignore: Spec.gitignore
-        }));
+        })));
         return result.diagnostics.map((d) => ({ ...d, file: Spec.relativize(d.file) }));
     }
     /*  render a diagnostic as a multi-line message with the affected
@@ -128,38 +137,38 @@ export class Spec {
         base directory into the requested formats, one buffer per format,
         collecting the emitted environment notices if requested  */
     static export(log, formats, notices) {
-        return Spec.unmarked(Spec.api(log, notices).export({
+        return Spec.unmarked(Spec.api(log, notices).then((api) => api.export({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
             gitignore: Spec.gitignore,
             formats
-        }));
+        })));
     }
     /*  export the specification like "export" and then keep the export
         in sync with its sources, handing every fresh set of buffers to
         "onExport", where "outputs" names the files "onExport" writes,
         so an output which is itself an observed source can be refused  */
     static watch(log, formats, outputs, onExport) {
-        return Spec.unmarked(Spec.api(log).watch({
+        return Spec.unmarked(Spec.api(log).then((api) => api.watch({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
             gitignore: Spec.gitignore,
             formats,
             outputs,
             onExport
-        }));
+        })));
     }
     /*  serve the HTML export of the specification as a live preview,
         kept in sync with its sources and pushed into the connected
         browsers as an in-place document update  */
     static preview(log, addr, port) {
-        return Spec.unmarked(Spec.api(log).preview({
+        return Spec.unmarked(Spec.api(log).then((api) => api.preview({
             config: Spec.configFiles(log),
             basedir: Artifact.basedir(log, "spec"),
             gitignore: Spec.gitignore,
             addr,
             port
-        }));
+        })));
     }
 }
 /*  CLI command "ase spec"  */
@@ -201,6 +210,7 @@ export default class SpecCommand {
             "(default: \"index.html\" inside the specification base directory)", (value, previous) => previous.concat(value), new Array())
             .option("-w, --watch", "keep the outputs in sync by re-exporting on every source change")
             .action(async (opts) => {
+            const { parseOutputSpec } = await import("@rse/specbook");
             const outputs = (opts.output.length > 0 ? opts.output :
                 [path.join(Artifact.basedir(this.log, "spec"), "index.html")]).map(parseOutputSpec);
             /*  a re-export has to land somewhere it can be picked up again,
@@ -232,13 +242,14 @@ export default class SpecCommand {
         spec
             .command("preview")
             .description("Serve the HTML export of the specification Markdown files as a live preview")
-            .option("-a, --addr <ip-addr>", "IP address to listen on", previewAddr)
-            .option("-p, --port <tcp-port>", "TCP port to listen on", String(previewPort))
+            .option("-a, --addr <ip-addr>", "IP address to listen on (default: SpecBook preview address)")
+            .option("-p, --port <tcp-port>", "TCP port to listen on (default: SpecBook preview port)")
             .action(async (opts) => {
-            const port = Number(opts.port);
+            const { previewAddr, previewPort } = await import("@rse/specbook");
+            const port = Number(opts.port ?? previewPort);
             if (!Number.isInteger(port) || port < 1 || port > 65535)
                 throw new Error(`invalid TCP port "${opts.port}"`);
-            await Spec.preview(this.log, opts.addr, port);
+            await Spec.preview(this.log, opts.addr ?? previewAddr, port);
             await new Promise(() => { });
         });
     }
@@ -314,7 +325,7 @@ export class SpecMCP {
                 "(like a PDF rendering falling back onto a system-installed browser), which are " +
                 "worth reporting to the user verbatim.",
             inputSchema: {
-                format: z.enum(formats).optional()
+                format: z.enum(Spec.formats).optional()
                     .describe("output format (default: inferred from the `output` file extension, else `json`)"),
                 output: z.string().optional()
                     .describe("output file path (\"-\" or omitted returns the result directly)")
@@ -326,6 +337,7 @@ export class SpecMCP {
         }, async (args) => {
             const notices = new Array();
             try {
+                const { parseOutputSpec } = await import("@rse/specbook");
                 /*  an explicit format takes the output as a plain file path, while
                     otherwise the output is an "[<format>:]<file>" specification  */
                 const spec = args.format !== undefined || args.output === undefined ?

package/dst/ase-statusline.js

@@ -10,8 +10,10 @@ import { execFileSync } from "node:child_process";
 import { InvalidArgumentError } from "commander";
 import { execaSync } from "execa";
 import { Chalk } from "chalk";
-import { Config, configSchema, parseScope } from "./ase-config.js";
-import { readStdin, writeStdout } from "./ase-stdio.js";
+import { Config, sessionState } from "./ase-config-core.js";
+import { configSchema } from "./ase-config-schema.js";
+import { parseScope, userStateDir, projectIdOf } from "./ase-config-scope.js";
+import { readStdin, writeStdout } from "./ase-lib-stdio.js";
 import pkg from "../package.json" with { type: "json" };
 /*  forced-color chalk instance: stdout is a pipe under Anthropic Claude Code CLI,
     so chalk auto-detection would yield level 0; force level 1 to keep
@@ -181,6 +183,69 @@ const memoize = (fn) => {
     let cache = null;
     return () => (cache ??= { value: fn() }).value;
 };
+/*  the ChatGPT backend endpoint providing the OpenAI Codex subscription usage  */
+const CODEX_USAGE = "https://chatgpt.com/backend-api/wham/usage";
+/*  time-to-live (in milliseconds) of the cached OpenAI Codex subscription usage  */
+const CODEX_USAGE_TTL = 60 * 1000;
+/*  fetch the rate-limit windows directly from the ChatGPT backend with the credential
+    stored by the OpenAI Codex CLI; the result (even a failed one) is cached for a short
+    time, as the statusline is rendered frequently, and no failure is ever raised  */
+const fetchCodexLimits = async () => {
+    /*  reuse the cached result while it is still fresh  */
+    const cacheFile = path.join(userStateDir(), "statusline-codex-usage.json");
+    let cache = {};
+    try {
+        cache = (JSON.parse(fs.readFileSync(cacheFile, "utf8")) ?? {});
+    }
+    catch (_e) {
+        /*  no (valid) cache yet  */
+    }
+    if (typeof cache.time === "number" && Math.abs(Date.now() - cache.time) < CODEX_USAGE_TTL)
+        return cache.limits;
+    /*  query the usage endpoint (keeping the stale result on any failure)  */
+    let limits = cache.limits;
+    try {
+        const home = process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex");
+        const auth = JSON.parse(fs.readFileSync(path.join(home, "auth.json"), "utf8"));
+        const token = auth?.tokens?.access_token;
+        if (typeof token === "string" && token !== "") {
+            const res = await fetch(CODEX_USAGE, {
+                headers: {
+                    "Authorization": `Bearer ${token}`,
+                    "ChatGPT-Account-ID": auth?.tokens?.account_id ?? "",
+                    "User-Agent": `ase/${pkg.version}`
+                },
+                signal: AbortSignal.timeout(3 * 1000)
+            });
+            if (res.ok) {
+                /*  classify windows by their length, as plans without a 5h limit
+                    report the 7d window in the primary slot  */
+                const usage = await res.json();
+                const wins = [usage?.rate_limit?.primary_window, usage?.rate_limit?.secondary_window]
+                    .filter((w) => w !== undefined && w !== null);
+                const win5h = wins.find((w) => (w.limit_window_seconds ?? 5 * 3600) < 24 * 3600);
+                const win7d = wins.find((w) => (w.limit_window_seconds ?? 0) >= 24 * 3600);
+                limits = {};
+                if (win5h !== undefined)
+                    limits.five_hour = { used_percentage: win5h.used_percent, resets_at: win5h.reset_at };
+                if (win7d !== undefined)
+                    limits.seven_day = { used_percentage: win7d.used_percent, resets_at: win7d.reset_at };
+            }
+        }
+    }
+    catch (_e) {
+        /*  credential unreadable or endpoint unreachable  */
+    }
+    /*  update the cache  */
+    try {
+        fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+        fs.writeFileSync(cacheFile, JSON.stringify({ time: Date.now(), limits }) + "\n", "utf8");
+    }
+    catch (_e) {
+        /*  best-effort  */
+    }
+    return limits;
+};
 /*  command-line handling  */
 export default class StatuslineCommand {
     log;
@@ -209,7 +274,7 @@ export default class StatuslineCommand {
             .option("-p, --padding <n>", "pad each rendered line with <n> spaces on each side", parseInteger("--padding"), 0)
             .option("--no-icons", "disable icons in placeholder rendering")
             .option("--no-labels", "disable labels in front of bold values")
-            .argument("[lines...]", "one or more template lines with %u %p %T %s %m %e %t %O %P %h %B %c %C %a %r " +
+            .argument("[lines...]", "one or more template lines with %u %p %T %s %m %e %t %O %P %h %B %L %c %C %a %r " +
             "%S %D %W %Q %H %X %b %g %G %d %M %V placeholders and <color>...</color> markup " +
             "(color: black, red, green, yellow, blue, magenta, cyan, white, default) " +
             "(default: single line \"%m %e %t\")")
@@ -282,30 +347,32 @@ export default class StatuslineCommand {
                 post-loop tmux publish for the Config cascade)  */
             const getSession = memoize(() => data.session_id ?? "unknown");
             const getCfg = memoize(() => {
-                let taskId = process.env.ASE_TASK_ID ?? "";
+                let taskId = process.env.ASE_TASK_ID ?? "default";
                 let persona = process.env.ASE_PERSONA_STYLE ?? "";
                 let guidance = process.env.ASE_GUIDANCE_LEVEL ?? "";
                 let boxing = process.env.ASE_PROJECT_BOXING ?? "";
+                let lifecycle = process.env.ASE_PROJECT_TASK_LIFECYCLE ?? "";
                 try {
                     const cfg = new Config("config", configSchema, this.log, parseScope(`session:${getSession()}`));
                     cfg.read("lenient");
-                    const t = String(cfg.get("agent.task") ?? "").trim();
-                    const p = String(cfg.get("agent.persona") ?? "").trim();
-                    const g = String(cfg.get("agent.guidance") ?? "").trim();
-                    const b = String(cfg.get("project.boxing") ?? "").trim();
-                    if (t !== "")
-                        taskId = t;
-                    if (p !== "")
-                        persona = p;
-                    if (g !== "")
-                        guidance = g;
-                    if (b !== "")
-                        boxing = b;
+                    const get = (key, fallback) => String(cfg.get(key) ?? "").trim() || fallback;
+                    persona = get("agent.persona", persona);
+                    guidance = get("agent.guidance", guidance);
+                    boxing = get("project.boxing", boxing);
+                    lifecycle = get("project.task.lifecycle", lifecycle);
                 }
                 catch (_e) {
                     /*  cascade unavailable; keep env-var fallbacks  */
                 }
-                return { taskId, persona, guidance, boxing };
+                try {
+                    const state = sessionState(this.log, getSession());
+                    state.read("lenient");
+                    taskId = String(state.get("task") ?? "").trim() || taskId;
+                }
+                catch (_e) {
+                    /*  session state unavailable; keep env-var fallback  */
+                }
+                return { taskId, persona, guidance, boxing, lifecycle };
             });
             const getModel = memoize(() => {
                 const display = data.model?.display_name ?? "";
@@ -318,6 +385,19 @@ export default class StatuslineCommand {
             });
             const getGit = memoize(() => probeGit(data.workspace?.current_dir ?? ""));
             const getMem = memoize(() => probeMemory());
+            /*  determine the rate-limit windows: regularly supplied by the harness on stdin,
+                but for OpenAI GPT models fetched directly as a fallback (and only on demand)  */
+            let limits = data.rate_limits;
+            if (limits?.five_hour === undefined && limits?.seven_day === undefined
+                && /^gpt-.+/i.test(getModel().name)
+                && tmpl.some((line) => /%[SDWQ]/.test(line)))
+                limits = await fetchCodexLimits();
+            /*  render a configuration value (if non-empty) with its icon and label  */
+            const cfgValue = (key, icon, label) => () => {
+                const value = getCfg()[key];
+                if (value !== "")
+                    emit(`${prefix(icon, label)}${c.bold(value)}`);
+            };
             /*  identifier to renderer map: each callback fetches its own information
                 directly from data (or via the lazy helpers above for shared values)  */
             const renderers = {
@@ -327,14 +407,10 @@ export default class StatuslineCommand {
                     emit(`${prefix("※", "user")}${c.bold(user)}`);
                 },
                 p: () => {
-                    const dir = path.basename(data.workspace?.current_dir ?? "");
-                    emit(`${prefix("⚑", "project")}${c.bold(dir)}`);
-                },
-                T: () => {
-                    const { taskId } = getCfg();
-                    if (taskId !== "")
-                        emit(`${prefix("◉", "task")}${c.bold(taskId)}`);
+                    const id = projectIdOf(data.workspace?.current_dir ?? "");
+                    emit(`${prefix("⚑", "project")}${c.bold(id)}`);
                 },
+                T: cfgValue("taskId", "◉", "task"),
                 s: () => emit(`${prefix("⏻", "session")}${c.bold(getSession())}`),
                 /*  ==== MODEL ====  */
                 m: () => {
@@ -355,21 +431,10 @@ export default class StatuslineCommand {
                     if (styleName !== "")
                         emit(`${prefix("≡", "style")}${c.bold(styleName)}`);
                 },
-                P: () => {
-                    const { persona } = getCfg();
-                    if (persona !== "")
-                        emit(`${prefix("☯", "persona")}${c.bold(persona)}`);
-                },
-                h: () => {
-                    const { guidance } = getCfg();
-                    if (guidance !== "")
-                        emit(`${prefix("▶", "guidance")}${c.bold(guidance)}`);
-                },
-                B: () => {
-                    const { boxing } = getCfg();
-                    if (boxing !== "")
-                        emit(`${prefix("▢", "boxing")}${c.bold(boxing)}`);
-                },
+                P: cfgValue("persona", "☯", "persona"),
+                h: cfgValue("guidance", "▶", "guidance"),
+                B: cfgValue("boxing", "▢", "boxing"),
+                L: cfgValue("lifecycle", "⟳", "lifecycle"),
                 /*  ==== CONTEXT ====  */
                 c: () => {
                     const pct = Math.min(100, Math.max(0, Math.floor(data.context_window?.used_percentage ?? 0)));
@@ -396,22 +461,22 @@ export default class StatuslineCommand {
                 },
                 /*  ==== RATE LIMITS ====  */
                 S: () => {
-                    const pct5h = data.rate_limits?.five_hour?.used_percentage;
+                    const pct5h = limits?.five_hour?.used_percentage;
                     const s = pct5h !== undefined ? `${pct5h.toFixed(1)}%` : "-";
                     emit(`${prefix("⏲", "5h-usage")}${c.bold(s)}`);
                 },
                 D: () => {
-                    const until5h = data.rate_limits?.five_hour?.resets_at;
+                    const until5h = limits?.five_hour?.resets_at;
                     const s = formatTimeUntil(until5h);
                     emit(`${prefix("⏱", "5h-resets")}${c.bold(s !== "" ? s : "-")}`);
                 },
                 W: () => {
-                    const pctWk = data.rate_limits?.seven_day?.used_percentage;
+                    const pctWk = limits?.seven_day?.used_percentage;
                     const s = pctWk !== undefined ? `${pctWk.toFixed(1)}%` : "-";
                     emit(`${prefix("⏲", "7d-usage")}${c.bold(s)}`);
                 },
                 Q: () => {
-                    const untilWk = data.rate_limits?.seven_day?.resets_at;
+                    const untilWk = limits?.seven_day?.resets_at;
                     const s = formatTimeUntil(untilWk);
                     emit(`${prefix("⏱", "7d-resets")}${c.bold(s !== "" ? s : "-")}`);
                 },