@rse/ase 1.0.4 → 1.0.6

package/dst/ase-artifact.js

@@ -10,6 +10,7 @@ import { isScalar } from "yaml";
 import { z } from "zod";
 import { Config, configSchema } from "./ase-config.js";
 import { Task } from "./ase-task.js";
+import { Ignore } from "./ase-ignore.js";
 import { writeStdout } from "./ase-stdio.js";
 /*  the recognized artifact kinds, in descending precedence order;
     "othr" is the implicit catch-all and is always resolved last  */
@@ -26,72 +27,22 @@ export class Artifact {
                 `(expected one of: ${artifactKinds.join(", ")})`);
         return kind;
     }
-    /*  translate a single ".gitignore" line into a picomatch-backed rule,
-        honoring the anchored-vs-floating, directory-only, and negation
-        semantics of ".gitignore" patterns; anchored patterns resolve
-        relative to the "base" directory holding the ".gitignore"  */
-    static compileIgnoreRule(line, base) {
-        let pattern = line.trim();
-        if (pattern === "" || pattern.startsWith("#"))
-            return null;
-        let negated = false;
-        if (pattern.startsWith("!")) {
-            negated = true;
-            pattern = pattern.slice(1);
-        }
-        let dirOnly = false;
-        if (pattern.endsWith("/")) {
-            dirOnly = true;
-            pattern = pattern.slice(0, -1);
-        }
-        const anchored = pattern.includes("/");
-        if (pattern.startsWith("/"))
-            pattern = pattern.slice(1);
-        const glob = anchored ? (base === "" ? pattern : `${base}/${pattern}`) : `**/${pattern}`;
-        const isMatch = picomatch(glob, { dot: true });
-        return { matcher: (p) => isMatch(p), negated, dirOnly };
-    }
-    /*  load the ".gitignore" rules located directly in a directory,
-        given as absolute "dir" and project-relative "relDir"  */
-    static loadIgnoreRules(dir, relDir) {
-        const file = path.join(dir, ".gitignore");
-        if (!fs.existsSync(file))
-            return [];
-        const rules = [];
-        for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
-            const rule = Artifact.compileIgnoreRule(line, relDir);
-            if (rule !== null)
-                rules.push(rule);
-        }
-        return rules;
-    }
-    /*  decide whether a project-relative path is ignored by the given
-        ordered ".gitignore" rule set (last matching rule wins)  */
-    static isIgnored(rel, isDir, rules) {
-        let ignored = false;
-        for (const rule of rules) {
-            if (rule.dirOnly && !isDir)
-                continue;
-            if (rule.matcher(rel))
-                ignored = !rule.negated;
-        }
-        return ignored;
-    }
     /*  build the file universe by walking the project tree from the
-        project root, honoring ".gitignore" rules (root plus nested) and
-        always pruning ".git". Yields POSIX project-relative, sorted,
+        project root, honoring the Git exclude rules (the repository-wide
+        ones plus the root and nested ".gitignore" files) and always
+        pruning ".git". Yields POSIX project-relative, sorted,
         de-duplicated file paths  */
     static universe() {
         const root = Task.projectRoot();
         const files = new Set();
         const walk = (dir, relDir, inherited) => {
-            const rules = [...inherited, ...Artifact.loadIgnoreRules(dir, relDir)];
+            const rules = [...inherited, ...Ignore.rules(dir, relDir)];
             for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
                 if (entry.name === ".git")
                     continue;
                 const rel = relDir === "" ? entry.name : `${relDir}/${entry.name}`;
                 const isDir = entry.isDirectory();
-                if (Artifact.isIgnored(rel, isDir, rules))
+                if (Ignore.matches(rel, isDir, rules))
                     continue;
                 if (isDir)
                     walk(path.join(dir, entry.name), rel, rules);
@@ -99,7 +50,7 @@ export class Artifact {
                     files.add(rel);
             }
         };
-        walk(root, "", []);
+        walk(root, "", Ignore.base(root));
         return [...files].sort((a, b) => a.localeCompare(b));
     }
     /*  raw-resolve a single kind's configuration spec against the file

package/dst/ase-config.js

@@ -10,12 +10,12 @@ 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";
 import writeFileAtomic from "write-file-atomic";
 import lockfile from "proper-lockfile";
 import { z } from "zod";
 import { LRUCache } from "lru-cache";
 import { writeStdout } from "./ase-stdio.js";
+import { renderTable } from "./ase-table.js";
 /*  classification taxonomy  */
 export const projectClassification = {
     boxing: ["white", "grey", "black"]
@@ -184,7 +184,8 @@ const artifactSchema = v.optional(v.strictObject({
     files: v.optional(v.string())
 }));
 /*  schema for the "spec" artifact kind, additionally carrying the
-    SpecBook YAML "schema" configuration file (empty: bundled standard)  */
+    whitespace-separated list of SpecBook YAML "schema" configuration
+    files, with "std" naming the bundled standard one (empty: "std")  */
 const artifactSpecSchema = v.optional(v.strictObject({
     basedir: v.optional(v.string()),
     files: v.optional(v.string()),
@@ -632,16 +633,12 @@ export default class ConfigCommand {
             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"] }
-            });
+            const rows = [];
             for (const e of cfg.entries()) {
                 const val = isScalar(e.value) ? e.value.value : e.value;
-                table.push([e.key, String(val), Config.scopeLabel(e.scope)]);
+                rows.push([e.key, String(val), Config.scopeLabel(e.scope)]);
             }
-            await writeStdout(`${table.toString()}\n`);
+            await writeStdout(renderTable(["KEY", "VALUE", "SCOPE"], rows));
         });
         /*  register CLI sub-command "ase config edit"  */
         configCmd

package/dst/ase-hook.js

@@ -208,9 +208,11 @@ export default class HookCommand {
         /*  determine path to external files  */
         const filePkg = path.join(pluginRoot, ".claude-plugin", "plugin.json");
         const fileMd = path.join(pluginRoot, "meta", "ase-constitution.md");
+        const fileStyle = path.join(pluginRoot, "output-styles", "ase-terse.md");
         /*  read external files  */
         let pkg;
         let md;
+        let style;
         try {
             pkg = fs.readFileSync(filePkg, "utf8");
         }
@@ -223,6 +225,12 @@ export default class HookCommand {
         catch (err) {
             throw new Error(`failed to read constitution file: ${fileMd}`, { cause: err });
         }
+        try {
+            style = fs.readFileSync(fileStyle, "utf8");
+        }
+        catch (err) {
+            throw new Error(`failed to read output style file: ${fileStyle}`, { cause: err });
+        }
         /*  determine own version  */
         const pkgObj = this.parseJSON(pkg, v.object({ version: v.optional(v.string()) }));
         const versionCurrentPlugin = pkgObj.version ?? "";
@@ -292,8 +300,8 @@ export default class HookCommand {
         const persona = setting("agent.persona", "ASE_PERSONA_STYLE", "engineer");
         const guidance = setting("agent.guidance", "ASE_GUIDANCE_LEVEL", "normal");
         const boxing = setting("project.boxing", "ASE_PROJECT_BOXING", "white");
-        /*  determine the specification base directory and the SpecBook
-            schema configuration (empty: the bundled standard schema)  */
+        /*  determine the specification base directory and the whitespace-separated
+            list of SpecBook schema configurations (empty: the bundled standard schema)  */
         const specBasedir = String(cfg.get("project.artifact.spec.basedir") ?? "");
         const specSchema = String(cfg.get("project.artifact.spec.schema") ?? "");
         /*  determine headless mode  */
@@ -340,6 +348,12 @@ export default class HookCommand {
                 "\n" + md;
         /*  expand all @<file> references manually  */
         md = this.expandReferences(md, path.dirname(fileMd));
+        /*  append the output style to the constitution markdown (GitHub
+            Copilot CLI and OpenAI Codex CLI only -- Anthropic Claude Code CLI
+            applies the plugin output style natively), stripping the
+            YAML frontmatter which only Anthropic Claude Code CLI understands  */
+        if (tool !== "claude")
+            md += "\n" + style.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "");
         /*  build the deterministic ASE banner (rendered directly by the
             agent harness, independent of any model decision, so it is
             guaranteed to appear once in every non-headless session;

package/dst/ase-ignore.js

@@ -0,0 +1,129 @@
+/*
+**  Agentic Software Engineering (ASE)
+**  Copyright (c) 2025-2026 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under Apache 2.0 <https://spdx.org/licenses/Apache-2.0>
+*/
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { execaSync } from "execa";
+import picomatch from "picomatch";
+import { LRUCache } from "lru-cache";
+/*  reusable functionality: decide which project-relative paths Git
+    excludes from the project, honoring the same three rule sources and
+    the same precedence order as Git itself -- the global excludes file,
+    the repository-local "info/exclude", and the per-directory
+    ".gitignore" files from the project root down to the path  */
+export class Ignore {
+    /*  translate a single Git exclude line into a picomatch-backed rule,
+        honoring the anchored-vs-floating, directory-only, and negation
+        semantics of the pattern; an anchored pattern resolves relative
+        to the "base" directory its rule file governs  */
+    static compile(line, base) {
+        let pattern = line.trim();
+        if (pattern === "" || pattern.startsWith("#"))
+            return null;
+        let negated = false;
+        if (pattern.startsWith("!")) {
+            negated = true;
+            pattern = pattern.slice(1);
+        }
+        let dirOnly = false;
+        if (pattern.endsWith("/")) {
+            dirOnly = true;
+            pattern = pattern.slice(0, -1);
+        }
+        const anchored = pattern.includes("/");
+        if (pattern.startsWith("/"))
+            pattern = pattern.slice(1);
+        const glob = anchored ? (base === "" ? pattern : `${base}/${pattern}`) : `**/${pattern}`;
+        const isMatch = picomatch(glob, { dot: true });
+        return { matcher: (p) => isMatch(p), negated, dirOnly };
+    }
+    /*  load the rules of a single exclude file, given as absolute "file"
+        and the project-relative "base" its anchored patterns resolve
+        against; a missing file simply contributes no rules  */
+    static load(file, base) {
+        if (file === "" || !fs.existsSync(file))
+            return [];
+        const rules = [];
+        for (const line of fs.readFileSync(file, "utf8").split(/\r?\n/)) {
+            const rule = Ignore.compile(line, base);
+            if (rule !== null)
+                rules.push(rule);
+        }
+        return rules;
+    }
+    /*  load the ".gitignore" rules located directly in a directory,
+        given as absolute "dir" and project-relative "relDir"  */
+    static rules(dir, relDir) {
+        return Ignore.load(path.join(dir, ".gitignore"), relDir);
+    }
+    /*  resolve the global Git excludes file: the configured
+        "core.excludesFile", or else the XDG location Git falls back
+        onto when that configuration value is unset  */
+    static globalFile() {
+        let file = "";
+        try {
+            file = execaSync("git", ["config", "--get", "core.excludesFile"], { stderr: "ignore" }).stdout.trim();
+        }
+        catch {
+            /*  no such configuration value  */
+        }
+        if (file === "") {
+            const xdg = process.env.XDG_CONFIG_HOME;
+            return xdg !== undefined && xdg !== "" ?
+                path.join(xdg, "git", "ignore") :
+                path.join(os.homedir(), ".config", "git", "ignore");
+        }
+        if (file.startsWith("~/"))
+            file = path.join(os.homedir(), file.slice(2));
+        return file;
+    }
+    /*  resolve the repository-local exclude file, held by the Git
+        *common* directory, so that a Git worktree shares the exclude
+        file of the main working tree it was created from  */
+    static infoFile(root) {
+        try {
+            const dir = execaSync("git", ["rev-parse", "--git-common-dir"], { cwd: root, stderr: "ignore" }).stdout.trim();
+            if (dir !== "")
+                return path.join(path.resolve(root, dir), "info", "exclude");
+        }
+        catch {
+            /*  not inside a Git working tree  */
+        }
+        return "";
+    }
+    /*  cached repository-wide rules (TTL-bounded, as the ASE service is
+        long-running and both the Git configuration and the exclude files
+        can change underneath it; each determination spawns Git, too)  */
+    static baseCache = new LRUCache({ max: 4, ttl: 10 * 1000 });
+    /*  the rules which no directory of the project owns and which hence
+        govern the project as a whole, in ascending Git precedence: the
+        global excludes file first, the repository-local "info/exclude"
+        second, so a later rule overrides an earlier one as it does in
+        Git; both anchor their patterns at the project root  */
+    static base(root) {
+        const cached = Ignore.baseCache.get(root);
+        if (cached !== undefined)
+            return cached;
+        const rules = [
+            ...Ignore.load(Ignore.globalFile(), ""),
+            ...Ignore.load(Ignore.infoFile(root), "")
+        ];
+        Ignore.baseCache.set(root, rules);
+        return rules;
+    }
+    /*  decide whether a project-relative path is excluded by the given
+        ordered rule set, where the last matching rule wins  */
+    static matches(rel, isDir, rules) {
+        let ignored = false;
+        for (const rule of rules) {
+            if (rule.dirOnly && !isDir)
+                continue;
+            if (rule.matcher(rel))
+                ignored = !rule.negated;
+        }
+        return ignored;
+    }
+}