@rse/ase 0.0.7 → 0.0.9

package/dst/ase-config.js

@@ -4,33 +4,278 @@
 **  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
 */
 import path from "node:path";
+import os from "node:os";
 import fs from "node:fs";
+import readline from "node:readline/promises";
 import { Document, parseDocument, isMap, isScalar } from "yaml";
 import { execaSync } from "execa";
 import * as v from "valibot";
 import Table from "cli-table3";
+/*  classification taxonomy  */
+export const projectClassification = {
+    source: {
+        ambition: ["artist", "craftsman", "engineer"],
+        boxing: ["white", "grey", "black"],
+        size: ["small", "medium", "large"],
+        structure: ["bare", "library", "framework"]
+    },
+    process: {
+        actors: ["person", "team", "crew"],
+        control: ["human", "hitl", "agent"],
+        drive: ["spec", "code", "test"]
+    },
+    result: {
+        target: ["prototype", "mvp", "product"]
+    }
+};
+/*  agent classification taxonomy  */
+export const agentClassification = {
+    persona: {
+        style: ["writer", "engineer", "telegrapher", "caveman"],
+        creativity: ["none", "lite", "full"]
+    },
+    process: {
+        autonomy: ["assistant", "hotl", "agent"]
+    }
+};
+/*  classification presets  */
+export const projectClassificationPresets = {
+    vibe: {
+        "project.id": "example",
+        "project.name": "Example Project",
+        "project.source.ambition": "engineer",
+        "project.source.boxing": "black",
+        "project.source.size": "small",
+        "project.source.structure": "bare",
+        "project.process.actors": "person",
+        "project.process.control": "agent",
+        "project.process.drive": "spec",
+        "project.result.target": "prototype",
+        "agent.persona.style": "writer",
+        "agent.persona.creativity": "full",
+        "agent.process.autonomy": "agent",
+    },
+    pro: {
+        "project.id": "example",
+        "project.name": "Example Project",
+        "project.source.ambition": "artist",
+        "project.source.boxing": "white",
+        "project.source.size": "medium",
+        "project.source.structure": "framework",
+        "project.process.actors": "person",
+        "project.process.control": "human",
+        "project.process.drive": "code",
+        "project.result.target": "product",
+        "agent.persona.style": "engineer",
+        "agent.persona.creativity": "none",
+        "agent.process.autonomy": "assistant",
+    },
+    default: {
+        "project.id": "example",
+        "project.name": "Example Project",
+        "project.source.ambition": "artist",
+        "project.source.boxing": "white",
+        "project.source.size": "medium",
+        "project.source.structure": "framework",
+        "project.process.actors": "person",
+        "project.process.control": "human",
+        "project.process.drive": "code",
+        "project.result.target": "product",
+        "agent.persona.style": "engineer",
+        "agent.persona.creativity": "none",
+        "agent.process.autonomy": "assistant",
+    },
+    industry: {
+        "project.id": "example",
+        "project.name": "Example Project",
+        "project.source.ambition": "craftsman",
+        "project.source.boxing": "grey",
+        "project.source.size": "large",
+        "project.source.structure": "framework",
+        "project.process.actors": "crew",
+        "project.process.control": "hitl",
+        "project.process.drive": "code",
+        "project.result.target": "mvp",
+        "agent.persona.style": "engineer",
+        "agent.persona.creativity": "none",
+        "agent.process.autonomy": "hotl",
+    }
+};
+/*  canonical ordering rank of a scope kind  */
+const scopeRank = (kind) => ({ default: -1, user: 0, project: 1, task: 2, session: 3 })[kind];
+/*  parse a single scope term  */
+const parseScopeTerm = (value) => {
+    if (value === "user")
+        return { kind: "user" };
+    else if (value === "project")
+        return { kind: "project" };
+    const m = /^(session|task):([A-Za-z0-9._-]+)$/.exec(value);
+    if (m !== null)
+        return { kind: m[1], id: m[2] };
+    throw new Error(`invalid --scope term "${value}" ` +
+        "(expected: \"user\", \"project\", \"task:<id>\", or \"session:<id>\")");
+};
+/*  detect whether a project context exists, i.e. either we are inside
+    a Git working tree or a ".ase" directory is present at or above cwd  */
+const hasProjectContext = () => {
+    try {
+        const result = execaSync("git", ["rev-parse", "--show-toplevel"], { stderr: "ignore" });
+        if (result.stdout.trim() !== "")
+            return true;
+    }
+    catch {
+        /*  not inside a Git working tree  */
+    }
+    let dir = fs.realpathSync(process.cwd());
+    for (;;) {
+        if (fs.existsSync(path.join(dir, ".ase")))
+            return true;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
+    }
+};
+/*  parse a raw "--scope" option value into a canonical Scope chain;
+    accepts a comma-separated list of terms in any order. The "user"
+    term is always implicitly added at the bottom of the chain; the
+    "project" term is implicitly added only when a project context
+    exists (Git repository or ".ase" directory at or above cwd), and
+    an explicit "project" term requires that same context  */
+const parseScope = (value) => {
+    const projectActive = hasProjectContext();
+    const input = (value === undefined || value === "") ?
+        (projectActive ? "project" : "user") :
+        value.trim();
+    if (input === "")
+        throw new Error("invalid --scope: value must not be empty");
+    const terms = input.split(",").map((s) => parseScopeTerm(s.trim()));
+    const seen = new Set();
+    for (const t of terms) {
+        if (seen.has(t.kind))
+            throw new Error(`invalid --scope: duplicate term of kind "${t.kind}"`);
+        seen.add(t.kind);
+    }
+    if (seen.has("project") && !projectActive)
+        throw new Error("invalid --scope: \"project\" requires a project context " +
+            "(a Git repository or a \".ase\" directory at or above the current directory)");
+    if (!seen.has("project") && projectActive)
+        terms.unshift({ kind: "project" });
+    if (!seen.has("user"))
+        terms.unshift({ kind: "user" });
+    terms.sort((a, b) => scopeRank(a.kind) - scopeRank(b.kind));
+    terms.unshift({ kind: "default" });
+    return terms;
+};
 /*  schema for ".ase/config.yaml"  */
 export const configSchema = v.nullish(v.strictObject({
     project: v.optional(v.strictObject({
-        id: v.optional(v.pipe(v.string(), v.minLength(1)))
+        id: v.optional(v.pipe(v.string(), v.minLength(1))),
+        name: v.optional(v.pipe(v.string(), v.minLength(1))),
+        source: v.optional(v.strictObject({
+            ambition: v.optional(v.picklist(projectClassification.source.ambition)),
+            boxing: v.optional(v.picklist(projectClassification.source.boxing)),
+            size: v.optional(v.picklist(projectClassification.source.size)),
+            structure: v.optional(v.picklist(projectClassification.source.structure))
+        })),
+        process: v.optional(v.strictObject({
+            actors: v.optional(v.picklist(projectClassification.process.actors)),
+            control: v.optional(v.picklist(projectClassification.process.control)),
+            drive: v.optional(v.picklist(projectClassification.process.drive))
+        })),
+        result: v.optional(v.strictObject({
+            target: v.optional(v.picklist(projectClassification.result.target))
+        }))
+    })),
+    agent: v.optional(v.strictObject({
+        persona: v.optional(v.strictObject({
+            style: v.optional(v.picklist(agentClassification.persona.style)),
+            creativity: v.optional(v.picklist(agentClassification.persona.creativity))
+        })),
+        process: v.optional(v.strictObject({
+            autonomy: v.optional(v.picklist(agentClassification.process.autonomy))
+        }))
     }))
 }));
-/*  encapsulate read/write access to a project-local ".ase/<name>.yaml" file  */
+/*  encapsulate read/write access to a stack of "<name>.yaml" configuration files,
+    each associated with a scope term; reads cascade along user < project < task < session,
+    writes are confined to the target (strongest) scope term  */
 export class Config {
+    /*  public state  */
     filename;
-    doc;
+    /*  private state  */
+    name;
+    scope;
     schema;
-    constructor(name, schema) {
-        const rel = path.join(".ase", `${name}.yaml`);
-        const found = this.findUpward(process.cwd(), rel);
-        this.filename = found ?? path.join(this.gitToplevel() ?? process.cwd(), rel);
-        this.doc = new Document();
+    log;
+    docs;
+    target;
+    /*  creation  */
+    constructor(name, schema, log, scope = [{ kind: "project" }]) {
+        if (scope.length === 0)
+            throw new Error("invalid scope: chain must not be empty");
+        this.name = name;
+        this.scope = scope[0].kind === "default" ? scope : [{ kind: "default" }, ...scope];
         this.schema = schema ?? null;
+        this.log = log;
+        const tgt = this.scope[this.scope.length - 1];
+        this.filename = this.resolveFilename(name, tgt);
+        this.docs = [{ scope: tgt, filename: this.filename, doc: new Document() }];
+        this.target = 0;
     }
-    /*  upward-walk on filesystem for a file path relative to a start directory  */
-    findUpward(start, rel) {
-        let dir = start;
-        for (;;) {
+    /*  render a scope term as a short textual label  */
+    static scopeLabel(term) {
+        if (term.kind === "default" || term.kind === "user" || term.kind === "project")
+            return term.kind;
+        return `${term.kind}:${term.id}`;
+    }
+    /*  resolve the per-OS user-scope base directory  */
+    userConfigDir() {
+        if (process.platform === "darwin")
+            /*  macOS  */
+            return path.join(os.homedir(), "Library", "Application Support", "ase");
+        else if (process.platform === "win32")
+            /*  Windows  */
+            return path.join(process.env.APPDATA ?? os.homedir(), "ase");
+        else {
+            /*  Linux  */
+            const xdg = process.env.XDG_CONFIG_HOME;
+            const base = xdg !== undefined && xdg !== "" ? xdg : path.join(os.homedir(), ".config");
+            return path.join(base, "ase");
+        }
+    }
+    /*  resolve the configuration filename based on the selected scope term  */
+    resolveFilename(name, term) {
+        if (term.kind === "default")
+            throw new Error("internal error: \"default\" scope has no filename");
+        if (term.kind === "user")
+            return path.join(this.userConfigDir(), `${name}.yaml`);
+        else if (term.kind === "project") {
+            const rel = path.join(".ase", `${name}.yaml`);
+            const cwd = process.cwd();
+            const top = this.gitToplevel();
+            const found = top !== null ?
+                this.findUpward(cwd, top, rel) :
+                (fs.existsSync(path.join(cwd, rel)) ? path.join(cwd, rel) : null);
+            return found ?? path.join(top ?? cwd, rel);
+        }
+        else {
+            const sub = term.kind === "session" ? "sessions" : "tasks";
+            const top = this.gitToplevel();
+            if (top !== null)
+                return path.join(top, ".ase", sub, term.id, `${name}.yaml`);
+            else
+                return path.join(this.userConfigDir(), sub, term.id, `${name}.yaml`);
+        }
+    }
+    /*  upward-walk on filesystem for a file path relative to a start directory,
+        bounded above (inclusive) by a stop directory  */
+    findUpward(start, stop, rel) {
+        let dir = fs.realpathSync(start);
+        const end = fs.realpathSync(stop);
+        const between = path.relative(end, dir);
+        const steps = between === "" ? 0 : between.split(path.sep).length;
+        for (let i = 0; i <= steps; i++) {
             const candidate = path.join(dir, rel);
             if (fs.existsSync(candidate))
                 return candidate;
@@ -39,6 +284,7 @@ export class Config {
                 return null;
             dir = parent;
         }
+        return null;
     }
     /*  determine the Git top-level directory, if inside a Git repository  */
     gitToplevel() {
@@ -52,24 +298,67 @@ export class Config {
             return null;
         }
     }
-    /*  read configuration file into memory  */
-    read() {
-        const text = fs.existsSync(this.filename) ? fs.readFileSync(this.filename, "utf8") : "";
-        this.doc = parseDocument(text);
-        this.validate("lenient");
+    /*  read the full scope chain into memory; the requested mode applies
+        to the target scope only, inherited scopes are always lenient  */
+    read(mode = "lenient") {
+        const chain = this.scope;
+        const docs = [];
+        for (let i = 0; i < chain.length; i++) {
+            const sc = chain[i];
+            if (sc.kind === "default") {
+                const doc = new Document();
+                doc.contents = doc.createNode({});
+                const preset = projectClassificationPresets.default;
+                for (const [k, val] of Object.entries(preset)) {
+                    const segments = k.split(".");
+                    for (let j = 1; j < segments.length; j++) {
+                        const prefix = segments.slice(0, j);
+                        const node = doc.getIn(prefix, true);
+                        if (node === undefined)
+                            doc.setIn(prefix, doc.createNode({}));
+                    }
+                    doc.setIn(segments, doc.createNode(val));
+                }
+                docs.push({ scope: sc, filename: "", doc });
+                continue;
+            }
+            const filename = this.resolveFilename(this.name, sc);
+            const isTarget = (i === chain.length - 1);
+            const perDocMode = isTarget ? mode : "lenient";
+            const text = fs.existsSync(filename) ? fs.readFileSync(filename, "utf8") : "";
+            let doc = parseDocument(text);
+            if (doc.errors.length > 0) {
+                const msg = `invalid YAML in ${filename}: ${doc.errors[0].message}`;
+                if (perDocMode === "strict")
+                    throw new Error(msg);
+                this.log.write("warning", msg);
+                doc = new Document();
+            }
+            docs.push({ scope: sc, filename, doc });
+        }
+        this.docs = docs;
+        this.target = docs.length - 1;
+        for (let i = 0; i < docs.length; i++) {
+            const isTarget = (i === this.target);
+            const perDocMode = isTarget ? mode : "lenient";
+            this.validateDoc(docs[i].doc, docs[i].filename, perDocMode);
+        }
     }
-    /*  write in-memory configuration back to file  */
+    /*  write in-memory configuration back to the target scope's file  */
     write() {
-        this.validate("strict");
-        fs.mkdirSync(path.dirname(this.filename), { recursive: true });
-        fs.writeFileSync(this.filename, this.doc.toString({ indent: 4 }), "utf8");
+        const td = this.docs[this.target];
+        if (td.scope.kind === "default")
+            throw new Error("internal error: \"default\" scope is not writable");
+        this.validateDoc(td.doc, td.filename, "strict");
+        fs.mkdirSync(path.dirname(td.filename), { recursive: true });
+        fs.writeFileSync(td.filename, td.doc.toString({ indent: 4 }), "utf8");
     }
-    /*  validate in-memory configuration against the optional schema  */
-    validate(mode = "strict") {
+    /*  validate a single YAML document against the optional schema  */
+    validateDoc(doc, filename, mode = "strict") {
         if (this.schema === null)
             return;
         for (;;) {
-            const result = v.safeParse(this.schema, this.doc.toJS());
+            const result = v.safeParse(this.schema, doc.toJS());
             if (result.success)
                 return;
             if (mode === "strict") {
@@ -77,112 +366,277 @@ export class Config {
                     const dotPath = (i.path ?? []).map((p) => String(p.key)).join(".");
                     return dotPath ? `${dotPath}: ${i.message}` : i.message;
                 }).join("; ");
-                throw new Error(`invalid configuration in ${this.filename}: ${issues}`);
+                throw new Error(`invalid configuration in ${filename}: ${issues}`);
             }
             let progressed = false;
             for (const i of result.issues) {
                 const segs = (i.path ?? []).map((p) => String(p.key));
                 const dotPath = segs.join(".");
-                process.stderr.write(`ase: warning: invalid entry in ${this.filename}: ${dotPath ? `${dotPath}: ` : ""}${i.message}\n`);
+                this.log.write("warning", `invalid entry in ${filename}: ${dotPath ? `${dotPath}: ` : ""}${i.message}`);
                 if (segs.length > 0) {
-                    this.doc.deleteIn(segs);
+                    doc.deleteIn(segs);
                     progressed = true;
                 }
+                else
+                    /*  root-level issue is structurally unrecoverable: do not wipe
+                        the document, let the next strict validate() surface it  */
+                    return;
             }
             if (!progressed)
                 return;
         }
     }
-    /*  retrieve a value at a dotted key, or the root contents if no key given  */
+    /*  enumerate all full dotted leaf paths from the attached valibot schema  */
+    schemaLeafPaths() {
+        const unwrap = (s) => {
+            while (s !== undefined && s !== null && (s.type === "optional" || s.type === "nullish"
+                || s.type === "nullable" || s.type === "undefinedable"))
+                s = s.wrapped;
+            return s;
+        };
+        const walk = (s, prefix) => {
+            const u = unwrap(s);
+            if (u !== undefined && u !== null
+                && (u.type === "object" || u.type === "strict_object" || u.type === "loose_object")
+                && u.entries !== undefined) {
+                const paths = [];
+                for (const [k, sub] of Object.entries(u.entries))
+                    paths.push(...walk(sub, [...prefix, k]));
+                return paths;
+            }
+            return [prefix];
+        };
+        return walk(this.schema, []);
+    }
+    /*  resolve a (possibly trailing-segment) dotted key to its full schema path  */
+    resolveKey(key) {
+        if (this.schema === null)
+            return key;
+        const segs = key.split(".");
+        const matches = this.schemaLeafPaths().filter((p) => {
+            if (p.length < segs.length)
+                return false;
+            for (let i = 0; i < segs.length; i++)
+                if (p[p.length - segs.length + i] !== segs[i])
+                    return false;
+            return true;
+        });
+        if (matches.length === 0)
+            return key;
+        if (matches.length > 1)
+            throw new Error(`ambiguous key "${key}" matches: ${matches.map((m) => m.join(".")).join(", ")}`);
+        return matches[0].join(".");
+    }
+    /*  retrieve the effective value at a dotted key (strongest scope wins),
+        or the target scope's root contents if no key is given  */
     get(key) {
         if (key === undefined)
-            return this.doc.contents;
-        return this.doc.getIn(key.split("."));
+            return this.docs[this.target].doc.contents;
+        const segs = this.resolveKey(key).split(".");
+        for (let i = this.docs.length - 1; i >= 0; i--) {
+            const v = this.docs[i].doc.getIn(segs);
+            if (v !== undefined)
+                return v;
+        }
+        return undefined;
     }
-    /*  set a value at a dotted key, creating intermediate maps as needed  */
+    /*  retrieve the effective value together with the scope it came from  */
+    getWithOrigin(key) {
+        const segs = this.resolveKey(key).split(".");
+        for (let i = this.docs.length - 1; i >= 0; i--) {
+            const v = this.docs[i].doc.getIn(segs);
+            if (v !== undefined)
+                return { value: v, scope: this.docs[i].scope };
+        }
+        return undefined;
+    }
+    /*  enumerate the effective leaf entries across the full scope chain;
+        each returned entry identifies the originating scope  */
+    entries() {
+        const keys = new Set();
+        const walk = (node, prefix) => {
+            if (isMap(node))
+                for (const item of node.items) {
+                    const k = [...prefix, String(item.key)];
+                    if (isMap(item.value))
+                        walk(item.value, k);
+                    else if (isScalar(item.value))
+                        keys.add(k.join("."));
+                    else
+                        throw new Error(`key "${k.join(".")}" has unsupported node type`);
+                }
+        };
+        for (const d of this.docs)
+            walk(d.doc.contents, []);
+        const result = [];
+        for (const k of keys) {
+            const segs = k.split(".");
+            for (let i = this.docs.length - 1; i >= 0; i--) {
+                const v = this.docs[i].doc.getIn(segs);
+                if (v !== undefined) {
+                    result.push({ key: k, value: v, scope: this.docs[i].scope });
+                    break;
+                }
+            }
+        }
+        result.sort((a, b) => a.key.localeCompare(b.key));
+        return result;
+    }
+    /*  set a value at a dotted key in the target scope, creating intermediate maps as needed  */
     set(key, value) {
-        const segments = key.split(".");
+        const segments = this.resolveKey(key).split(".");
+        const td = this.docs[this.target];
+        const next = td.doc.clone();
         for (let i = 1; i < segments.length; i++) {
             const prefix = segments.slice(0, i);
-            const node = this.doc.getIn(prefix, true);
-            if (!isMap(node))
-                this.doc.setIn(prefix, this.doc.createNode({}));
+            const node = next.getIn(prefix, true);
+            if (node !== undefined && !isMap(node))
+                throw new Error(`cannot set "${key}": intermediate path "${prefix.join(".")}" is not a map`);
+            if (node === undefined)
+                next.setIn(prefix, next.createNode({}));
+        }
+        next.setIn(segments, value);
+        const saved = td.doc;
+        td.doc = next;
+        try {
+            this.validateDoc(td.doc, td.filename, "strict");
+        }
+        catch (err) {
+            td.doc = saved;
+            throw err;
         }
-        this.doc.setIn(segments, value);
-        this.validate("strict");
     }
-    /*  delete a value at a dotted key  */
+    /*  delete a value at a dotted key from the target scope  */
     delete(key) {
-        this.doc.deleteIn(key.split("."));
+        const td = this.docs[this.target];
+        const next = td.doc.clone();
+        next.deleteIn(this.resolveKey(key).split("."));
+        const saved = td.doc;
+        td.doc = next;
+        try {
+            this.validateDoc(td.doc, td.filename, "strict");
+        }
+        catch (err) {
+            td.doc = saved;
+            throw err;
+        }
     }
 }
-/*  register CLI command "ase config"  */
-const registerConfigCommand = (program) => {
-    const configCmd = program
-        .command("config")
-        .description("Manage ASE configuration")
-        .action((_opts, cmd) => {
-        cmd.help();
-    });
-    /*  register CLI sub-command "ase config get"  */
-    configCmd
-        .command("get")
-        .description("Print the value at a dotted configuration key")
-        .argument("<key>", "Configuration key (dotted path)")
-        .action((key) => {
-        const cfg = new Config("config", configSchema);
-        cfg.read();
-        const v = cfg.get(key);
-        if (isMap(v))
-            throw new Error(`key "${key}" is not a leaf key`);
-        console.log(isScalar(v) ? v.value : v);
-    });
-    /*  register CLI sub-command "ase config set"  */
-    configCmd
-        .command("set")
-        .description("Set the value at a dotted configuration key")
-        .argument("<key>", "Configuration key (dotted path)")
-        .argument("<value>", "Configuration value")
-        .action((key, value) => {
-        const cfg = new Config("config", configSchema);
-        cfg.read();
-        console.log(`${key}: ${value}`);
-        cfg.set(key, value);
-        cfg.write();
-    });
-    /*  register CLI sub-command "ase config list"  */
-    configCmd
-        .command("list")
-        .description("List all configured values as flat dotted keys")
-        .action(() => {
-        const cfg = new Config("config", configSchema);
-        cfg.read();
-        const table = new Table({ head: ["key", "value"] });
-        const list = (node, prefix) => {
-            if (isMap(node))
-                for (const item of node.items) {
-                    const k = prefix ? `${prefix}.${item.key}` : String(item.key);
-                    if (isMap(item.value))
-                        list(item.value, k);
-                    else
-                        table.push([k, String(isScalar(item.value) ? item.value.value : item.value)]);
+/*  CLI command "ase config"  */
+export default class ConfigCommand {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    /*  register commands  */
+    register(program) {
+        /*  register CLI top-level command "ase config"  */
+        const configCmd = program
+            .command("config")
+            .option("--scope <scope>", "configuration scope chain: comma-separated list of \"user\", \"project\", " +
+            "\"task:<id>\", and/or \"session:<id>\" terms (e.g. \"task:N,session:M\"); " +
+            "\"user\" is always implicitly included and \"project\" is implicitly " +
+            "included whenever a project context (Git repo or upward \".ase\" directory) exists")
+            .description("manage ASE configuration")
+            .action((_opts, cmd) => {
+            cmd.outputHelp();
+            process.exit(1);
+        });
+        /*  register CLI sub-command "ase config init"  */
+        configCmd
+            .command("init")
+            .description("initialize configuration with preset values (default|vibe|pro|industry)")
+            .argument("<type>", "Preset type (default|vibe|pro|industry)")
+            .action((type, _opts, cmd) => {
+            const scope = parseScope(cmd.optsWithGlobals().scope);
+            const preset = projectClassificationPresets[type];
+            if (preset === undefined)
+                throw new Error(`unknown preset "${type}" (expected: default|vibe|pro|industry)`);
+            const cfg = new Config("config", configSchema, this.log, scope);
+            cfg.read();
+            for (const [k, val] of Object.entries(preset))
+                cfg.set(k, val);
+            cfg.write();
+        });
+        /*  register CLI sub-command "ase config list"  */
+        configCmd
+            .command("list")
+            .description("list all configured values as flat dotted keys")
+            .action((_opts, cmd) => {
+            const scope = parseScope(cmd.optsWithGlobals().scope);
+            const cfg = new Config("config", configSchema, this.log, scope);
+            cfg.read();
+            const table = new Table({
+                head: ["KEY", "VALUE", "SCOPE"],
+                chars: { "mid": "", "left-mid": "", "mid-mid": "", "right-mid": "" },
+                style: { head: ["blue"] }
+            });
+            for (const e of cfg.entries()) {
+                const v = isScalar(e.value) ? e.value.value : e.value;
+                table.push([e.key, String(v), Config.scopeLabel(e.scope)]);
+            }
+            process.stdout.write(`${table.toString()}\n`);
+        });
+        /*  register CLI sub-command "ase config edit"  */
+        configCmd
+            .command("edit")
+            .description("edit configuration file with $EDITOR")
+            .action(async (_opts, cmd) => {
+            const scope = parseScope(cmd.optsWithGlobals().scope);
+            const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+            const cfg = new Config("config", configSchema, this.log, scope);
+            fs.mkdirSync(path.dirname(cfg.filename), { recursive: true });
+            if (!fs.existsSync(cfg.filename))
+                fs.writeFileSync(cfg.filename, "", "utf8");
+            const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+            try {
+                for (;;) {
+                    execaSync(editor, [cfg.filename], { stdio: "inherit" });
+                    try {
+                        cfg.read("strict");
+                        break;
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        this.log.write("error", msg);
+                        const ans = (await rl.question("re-edit? [Y/n] ")).trim().toLowerCase();
+                        if (ans === "n" || ans === "no")
+                            throw err;
+                    }
                 }
-        };
-        list(cfg.get(), "");
-        console.log(table.toString());
-    });
-    /*  register CLI sub-command "ase config edit"  */
-    configCmd
-        .command("edit")
-        .description("Edit configuration file with $EDITOR")
-        .action(() => {
-        const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
-        const cfg = new Config("config", configSchema);
-        fs.mkdirSync(path.dirname(cfg.filename), { recursive: true });
-        if (!fs.existsSync(cfg.filename))
-            fs.writeFileSync(cfg.filename, "", "utf8");
-        execaSync(editor, [cfg.filename], { stdio: "inherit" });
-        cfg.read();
-    });
-};
-export default registerConfigCommand;
+            }
+            finally {
+                rl.close();
+            }
+        });
+        /*  register CLI sub-command "ase config get"  */
+        configCmd
+            .command("get")
+            .description("print the value at a dotted configuration key")
+            .argument("<key>", "configuration key (dotted path)")
+            .action((key, _opts, cmd) => {
+            const scope = parseScope(cmd.optsWithGlobals().scope);
+            const cfg = new Config("config", configSchema, this.log, scope);
+            cfg.read();
+            const val = cfg.get(key);
+            if (val === undefined)
+                throw new Error(`key "${key}" is not set`);
+            if (isMap(val))
+                throw new Error(`key "${key}" is not a leaf key`);
+            process.stdout.write(`${isScalar(val) ? val.value : val}\n`);
+        });
+        /*  register CLI sub-command "ase config set"  */
+        configCmd
+            .command("set")
+            .description("set the value at a dotted configuration key")
+            .argument("<key>", "configuration key (dotted path)")
+            .argument("<value>", "configuration value")
+            .action((key, value, _opts, cmd) => {
+            const scope = parseScope(cmd.optsWithGlobals().scope);
+            const cfg = new Config("config", configSchema, this.log, scope);
+            cfg.read();
+            cfg.set(key, value);
+            cfg.write();
+        });
+    }
+}