@stigmer/cli 3.15.3-dev.20260916211208 → 3.16.1-dev.20260917224426

package/src/resources/ignore/ignore.test.ts

@@ -1,86 +1,17 @@
-// Table tests for the gitignore-compatible ignore engine: the filepath.Match
-// port, the Pattern matcher (scoping, dir-only, globs, negation), and the
-// composed Matcher with source precedence + last-match-wins.
+// The CLI's ignore edge: `createMatcher` reads `.gitignore` and
+// `.stigmerignore` from the directory and builds the shared engine's matcher
+// from their text. The engine's own tables (patterns, precedence,
+// last-match-wins) live with the engine in `@stigmer/plugin-package`; what is
+// pinned here is the disk reading — which files, honouring `respectGitignore`,
+// an absent file contributing nothing.
 
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { matchName } from "./match.js";
 import { createMatcher } from "./matcher.js";
-import { MatchResult, parsePattern } from "./pattern.js";
 
-describe("matchName (filepath.Match port)", () => {
-  const cases: [string, string, boolean][] = [
-    ["*.go", "main.go", true],
-    ["*.go", "main.rs", false],
-    ["*", "anything", true],
-    ["a?c", "abc", true],
-    ["a?c", "ac", false],
-    ["[abc]", "b", true],
-    ["[abc]", "d", false],
-    ["[a-c]", "b", true],
-    ["[a-c]", "z", false],
-    ["[^a]", "b", true],
-    ["[^a]", "a", false],
-    ["foo*", "foobar", true],
-    ["*bar", "foobar", true],
-    ["h[a-z]llo", "hello", true],
-    ["node_modules", "node_modules", true],
-    ["\\*.go", "*.go", true],
-    // Malformed patterns: Go returns ErrBadPattern → callers treat as no match.
-    ["[", "a", false],
-    ["[a-", "a", false],
-  ];
-  for (const [pattern, name, expected] of cases) {
-    it(`${pattern} ~ ${name} => ${expected}`, () => {
-      expect(matchName(pattern, name)).toBe(expected);
-    });
-  }
-});
-
-describe("parsePattern / Pattern.match", () => {
-  it("directory-only patterns only match directories (or ancestors)", () => {
-    const p = parsePattern("node_modules/", []);
-    expect(p.match(["node_modules"], true)).toBe(MatchResult.Exclude);
-    expect(p.match(["node_modules"], false)).toBe(MatchResult.NoMatch);
-    expect(p.match(["src", "node_modules"], true)).toBe(MatchResult.Exclude);
-  });
-
-  it("simple name patterns match at any depth", () => {
-    const p = parsePattern("*.log", []);
-    expect(p.match(["app.log"], false)).toBe(MatchResult.Exclude);
-    expect(p.match(["sub", "app.log"], false)).toBe(MatchResult.Exclude);
-    expect(p.match(["app.txt"], false)).toBe(MatchResult.NoMatch);
-  });
-
-  it("leading slash anchors to the domain root", () => {
-    const p = parsePattern("/build", []);
-    expect(p.match(["build"], true)).toBe(MatchResult.Exclude);
-    expect(p.match(["src", "build"], true)).toBe(MatchResult.NoMatch);
-  });
-
-  it("** matches zero-to-many directories", () => {
-    const p = parsePattern("**/foo", []);
-    expect(p.match(["foo"], false)).toBe(MatchResult.Exclude);
-    expect(p.match(["a", "b", "foo"], false)).toBe(MatchResult.Exclude);
-    expect(p.match(["a", "bar"], false)).toBe(MatchResult.NoMatch);
-  });
-
-  it("negation patterns produce Include", () => {
-    const p = parsePattern("!keep.txt", []);
-    expect(p.inclusion).toBe(true);
-    expect(p.match(["keep.txt"], false)).toBe(MatchResult.Include);
-  });
-
-  it("domain scopes matching below a subtree", () => {
-    const p = parsePattern("*.txt", ["sub"]);
-    expect(p.match(["sub", "a.txt"], false)).toBe(MatchResult.Exclude);
-    expect(p.match(["a.txt"], false)).toBe(MatchResult.NoMatch);
-  });
-});
-
-describe("createMatcher (source precedence, last-match-wins)", () => {
+describe("createMatcher (the disk edge over the shared engine)", () => {
   let dir: string;
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), "ignore-test-"));
@@ -89,51 +20,43 @@ describe("createMatcher (source precedence, last-match-wins)", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
-  it("applies security defaults including the .env.example negation", () => {
-    const m = createMatcher({ rootDir: dir, respectGitignore: false, includeDefaults: true });
+  it("applies the security defaults with no ignore files present", () => {
+    const m = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
     expect(m.match(".env", false)).toBe(true);
     expect(m.match(".env.example", false)).toBe(false);
-    expect(m.match("id_rsa", false)).toBe(true);
-    expect(m.match("node_modules", true)).toBe(true);
   });
 
-  it("honors .gitignore with negation (last match wins)", () => {
+  it("reads .gitignore from the root when respected, and not otherwise", () => {
     writeFileSync(join(dir, ".gitignore"), "*.draft\n!keep.draft\n");
-    const m = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
-    expect(m.match("notes.draft", false)).toBe(true);
-    expect(m.match("keep.draft", false)).toBe(false);
-  });
-
-  it("ignores .gitignore when respectGitignore is false", () => {
-    writeFileSync(join(dir, ".gitignore"), "*.draft\n");
-    const m = createMatcher({ rootDir: dir, respectGitignore: false, includeDefaults: true });
-    expect(m.match("notes.draft", false)).toBe(false);
+    const respected = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
+    expect(respected.match("notes.draft", false)).toBe(true);
+    expect(respected.match("keep.draft", false)).toBe(false);
+    const ignored = createMatcher({ rootDir: dir, respectGitignore: false, includeDefaults: true });
+    expect(ignored.match("notes.draft", false)).toBe(false);
   });
 
-  it(".stigmerignore is always loaded and outranks .gitignore", () => {
+  it("always reads .stigmerignore, which outranks .gitignore", () => {
     writeFileSync(join(dir, ".gitignore"), "!shared.draft\n");
     writeFileSync(join(dir, ".stigmerignore"), "*.draft\n");
     const m = createMatcher({ rootDir: dir, respectGitignore: true, includeDefaults: true });
     expect(m.match("shared.draft", false)).toBe(true);
   });
 
-  it("CLI extra ignore/include override file sources", () => {
-    writeFileSync(join(dir, ".gitignore"), "*.draft\n");
+  it("passes the CLI flags through", () => {
     const m = createMatcher({
       rootDir: dir,
       respectGitignore: true,
       includeDefaults: true,
       extraIgnore: ["*.tmp"],
-      extraInclude: ["important.draft"],
+      extraInclude: ["important.tmp"],
     });
     expect(m.match("scratch.tmp", false)).toBe(true);
-    expect(m.match("important.draft", false)).toBe(false);
+    expect(m.match("important.tmp", false)).toBe(false);
   });
 
-  it("reports the matching source and reason", () => {
-    const m = createMatcher({ rootDir: dir, respectGitignore: false, includeDefaults: true });
-    const reason = m.matchWithReason(".env", false);
-    expect(reason.ignored).toBe(true);
-    expect(reason.source).toBe("defaults");
+  it("refuses a root that is not a directory", () => {
+    expect(() => createMatcher({ rootDir: "", respectGitignore: true, includeDefaults: true })).toThrow(
+      "rootDir is required",
+    );
   });
 });

package/src/resources/ignore/index.ts

@@ -1,17 +1,20 @@
-// Public surface of the gitignore-compatible ignore engine.
+// Public surface of the CLI's ignore edge. The engine is
+// `@stigmer/plugin-package/client`; re-exported here so the CLI's callers keep
+// one import path and the shared engine stays the only implementation.
 
-export { DEFAULT_PATTERNS } from "./defaults.js";
-export { matchName } from "./match.js";
 export {
-  createMatcher,
-  type MatcherOptions,
+  DEFAULT_PATTERNS,
   type MatchReason,
+  MatchResult,
   Matcher,
-  Reason,
+  type Pattern,
   REASON_TEXT,
+  Reason,
   SOURCE_CLI,
   SOURCE_DEFAULTS,
   SOURCE_GITIGNORE,
   SOURCE_STIGMERIGNORE,
-} from "./matcher.js";
-export { MatchResult, type Pattern, parsePattern } from "./pattern.js";
+  matchName,
+  parsePattern,
+} from "@stigmer/plugin-package/client";
+export { createMatcher, type MatcherOptions } from "./matcher.js";

package/src/resources/ignore/matcher.ts

@@ -1,43 +1,21 @@
-// Ignore matcher: composes pattern sources with gitignore precedence (defaults
-// → .gitignore → .stigmerignore → CLI flags), evaluating "last match wins".
-// A faithful port of the Go CLI's pkg/ignore Matcher.
+// The CLI's edge for the shared ignore engine: read the ignore files from the
+// directory about to be packaged and build the matcher from their text.
+//
+// The engine itself (patterns, precedence, last-match-wins, the security
+// defaults) lives in `@stigmer/plugin-package/client`, where the console
+// builds the same matcher from a marketplace tree's file list. What is left
+// here is what only a filesystem client needs: which files to read and that
+// an absent or unreadable ignore file is normal and contributes nothing.
 
 import { readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { DEFAULT_PATTERNS } from "./defaults.js";
-import { MatchResult, type Pattern, parsePattern } from "./pattern.js";
-
-export const SOURCE_DEFAULTS = "defaults";
-export const SOURCE_GITIGNORE = ".gitignore";
-export const SOURCE_STIGMERIGNORE = ".stigmerignore";
-export const SOURCE_CLI = "cli";
-
-export enum Reason {
-  NoMatch = 0,
-  Excluded = 1,
-  Included = 2,
-  DefaultDeny = 3,
-}
-
-export const REASON_TEXT: Readonly<Record<Reason, string>> = {
-  [Reason.NoMatch]: "no pattern matched",
-  [Reason.Excluded]: "excluded by pattern",
-  [Reason.Included]: "included by negation pattern",
-  [Reason.DefaultDeny]: "excluded by security default",
-};
-
-export interface MatchReason {
-  readonly ignored: boolean;
-  readonly reason: Reason;
-  readonly source: string;
-  readonly pattern: string;
-}
-
-interface PatternEntry {
-  readonly pattern: Pattern;
-  readonly source: string;
-  readonly raw: string;
-}
+import {
+  type IgnoreSources,
+  type Matcher,
+  SOURCE_GITIGNORE,
+  SOURCE_STIGMERIGNORE,
+  buildMatcher,
+} from "@stigmer/plugin-package/client";
 
 export interface MatcherOptions {
   readonly rootDir: string;
@@ -47,112 +25,31 @@ export interface MatcherOptions {
   readonly extraInclude?: readonly string[];
 }
 
-export class Matcher {
-  private readonly entries: readonly PatternEntry[];
-
-  constructor(entries: readonly PatternEntry[]) {
-    this.entries = entries;
-  }
-
-  /** Decide whether a path (relative, forward-slash) is ignored, with reason. */
-  matchWithReason(path: string, isDir: boolean): MatchReason {
-    const components = pathToComponents(path);
-    if (components.length === 0) {
-      return { ignored: false, reason: Reason.NoMatch, source: "", pattern: "" };
-    }
-
-    let lastMatch: PatternEntry | undefined;
-    let lastResult = MatchResult.NoMatch;
-    for (const entry of this.entries) {
-      const result = entry.pattern.match(components, isDir);
-      if (result !== MatchResult.NoMatch) {
-        lastMatch = entry;
-        lastResult = result;
-      }
-    }
-
-    if (lastMatch === undefined) {
-      return { ignored: false, reason: Reason.NoMatch, source: "", pattern: "" };
-    }
-
-    if (lastResult === MatchResult.Exclude) {
-      const reason = lastMatch.source === SOURCE_DEFAULTS ? Reason.DefaultDeny : Reason.Excluded;
-      return { ignored: true, reason, source: lastMatch.source, pattern: lastMatch.raw };
-    }
-    // Include (negation): explicitly un-ignored.
-    return { ignored: false, reason: Reason.Included, source: lastMatch.source, pattern: lastMatch.raw };
-  }
-
-  /** Whether the path should be excluded from the artifact. */
-  match(path: string, isDir: boolean): boolean {
-    return this.matchWithReason(path, isDir).ignored;
-  }
-
-  /** All loaded patterns as "[source] pattern" (for dry-run diagnostics). */
-  patterns(): string[] {
-    return this.entries.map((entry) => `[${entry.source}] ${entry.raw}`);
-  }
-}
-
-/** Build a Matcher for `rootDir`, loading the configured pattern sources. */
+/** Build a Matcher for `rootDir`, loading the configured pattern sources from disk. */
 export function createMatcher(options: MatcherOptions): Matcher {
   if (options.rootDir === "") throw new Error("rootDir is required");
   const stat = statSync(options.rootDir);
   if (!stat.isDirectory()) throw new Error(`rootDir is not a directory: ${options.rootDir}`);
 
-  const entries: PatternEntry[] = [];
-  if (options.includeDefaults) {
-    entries.push(...parseEntries(DEFAULT_PATTERNS, SOURCE_DEFAULTS));
-  }
-  if (options.respectGitignore) {
-    entries.push(...loadIgnoreFile(join(options.rootDir, ".gitignore"), SOURCE_GITIGNORE));
-  }
-  entries.push(...loadIgnoreFile(join(options.rootDir, ".stigmerignore"), SOURCE_STIGMERIGNORE));
-
-  const extraIgnore = options.extraIgnore ?? [];
-  const extraInclude = options.extraInclude ?? [];
-  if (extraIgnore.length > 0 || extraInclude.length > 0) {
-    entries.push(...loadCliPatterns(extraIgnore, extraInclude));
-  }
-
-  return new Matcher(entries);
-}
-
-function parseEntries(patterns: readonly string[], source: string): PatternEntry[] {
-  const entries: PatternEntry[] = [];
-  for (const raw of patterns) {
-    const trimmed = raw.trim();
-    if (trimmed === "" || trimmed.startsWith("#")) continue;
-    entries.push({ pattern: parsePattern(trimmed, []), source, raw: trimmed });
-  }
-  return entries;
-}
-
-function loadIgnoreFile(path: string, source: string): PatternEntry[] {
-  let text: string;
+  const gitignore = options.respectGitignore
+    ? readIgnoreFile(join(options.rootDir, SOURCE_GITIGNORE))
+    : undefined;
+  const stigmerignore = readIgnoreFile(join(options.rootDir, SOURCE_STIGMERIGNORE));
+  const sources: IgnoreSources = {
+    includeDefaults: options.includeDefaults,
+    ...(gitignore !== undefined && { gitignore }),
+    ...(stigmerignore !== undefined && { stigmerignore }),
+    ...(options.extraIgnore !== undefined && { extraIgnore: options.extraIgnore }),
+    ...(options.extraInclude !== undefined && { extraInclude: options.extraInclude }),
+  };
+  return buildMatcher(sources);
+}
+
+function readIgnoreFile(path: string): string | undefined {
   try {
-    text = readFileSync(path, "utf8");
+    return readFileSync(path, "utf8");
   } catch {
     // Absent or unreadable ignore files are normal — no patterns.
-    return [];
+    return undefined;
   }
-  return parseEntries(text.split(/\r?\n/), source);
-}
-
-function loadCliPatterns(ignore: readonly string[], include: readonly string[]): PatternEntry[] {
-  const entries = parseEntries(ignore, SOURCE_CLI);
-  const negations: string[] = [];
-  for (const pattern of include) {
-    const trimmed = pattern.trim();
-    if (trimmed === "") continue;
-    negations.push(trimmed.startsWith("!") ? trimmed : `!${trimmed}`);
-  }
-  entries.push(...parseEntries(negations, SOURCE_CLI));
-  return entries;
-}
-
-function pathToComponents(path: string): string[] {
-  const normalized = path.replace(/\\/g, "/").replace(/^\.\//, "");
-  if (normalized === "" || normalized === ".") return [];
-  return normalized.split("/");
 }

package/src/resources/plugin.test.ts

@@ -1,7 +1,9 @@
 // Pins the plugin directory walker: detection by any of the four manifests,
 // sorted sized entries, the ignore matcher applied (defaults, .gitignore,
 // .stigmerignore), symlinks never followed, and the JSON projection that
-// reduces overlay documents to their paths.
+// reduces overlay documents to their paths; then the prepared push (the
+// deterministic archive and its SHA-256, the server's own digest) and the
+// install summary renderer.
 
 import {
   mkdirSync,
@@ -132,13 +134,13 @@ describe("readPluginDirectory", () => {
   });
 });
 
-describe("zipPluginFiles", () => {
-  it("writes the walked list deterministically and round-trips through the library's own reader", async () => {
-    const { zipPluginFiles } = await import("./plugin.js");
+describe("the archive of a walked directory", () => {
+  it("is deterministic and round-trips through the library's own reader", async () => {
+    const { archivePlugin } = await import("@stigmer/plugin-package/client");
     const { unzipSync } = await import("fflate");
     const directory = readPluginDirectory(root);
-    const first = zipPluginFiles(directory.files);
-    const second = zipPluginFiles(directory.files);
+    const first = archivePlugin(directory.files);
+    const second = archivePlugin(directory.files);
     expect(Buffer.from(first).equals(Buffer.from(second))).toBe(true);
     const entries = Object.keys(unzipSync(first)).sort();
     expect(entries).toEqual(directory.files.entries.map((e) => e.path));
@@ -147,6 +149,33 @@ describe("zipPluginFiles", () => {
   });
 });
 
+describe("preparePluginPush", () => {
+  it("carries the walked archive and its SHA-256, the identity the server records", async () => {
+    const { createHash } = await import("node:crypto");
+    const { preparePluginPush } = await import("./plugin.js");
+    const { archivePlugin } = await import("@stigmer/plugin-package/client");
+    const prepared = await preparePluginPush(root);
+    expect(prepared.plugin.name).toBe("walker");
+    expect(prepared.dir).toBe(root);
+    expect(prepared.stats.filesIgnored).toBe(3);
+    const bytes = archivePlugin(readPluginDirectory(root).files);
+    expect(Buffer.from(prepared.archive).equals(Buffer.from(bytes))).toBe(true);
+    expect(prepared.digest).toBe(createHash("sha256").update(bytes).digest("hex"));
+    expect(prepared.digest).toMatch(/^[a-f0-9]{64}$/);
+  });
+
+  it("refuses offline with the same sentences validate prints", async () => {
+    const { preparePluginPush } = await import("./plugin.js");
+    const broken = mkdtempSync(join(tmpdir(), "stigmer-plugin-broken-"));
+    try {
+      writeFileSync(join(broken, "plugin.json"), JSON.stringify({ name: "Not Valid!" }));
+      await expect(preparePluginPush(broken)).rejects.toThrow(/plugin cannot be installed/);
+    } finally {
+      rmSync(broken, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("renderPushOutcome", () => {
   it("summarises the install by kind, lists members and carries warnings", async () => {
     const { renderPushOutcome } = await import("./plugin.js");