@stigmer/cli 3.16.0 → 3.16.1-dev.20260917224426

package/src/resources/ignore/defaults.ts

@@ -1,155 +0,0 @@
-// Built-in security-first ignore patterns, applied (lowest priority) unless
-// disabled. A verbatim port of the Go CLI's DefaultPatterns so `push` excludes
-// the same secrets, VCS metadata, and build artifacts on both CLIs.
-
-export const DEFAULT_PATTERNS: readonly string[] = [
-  // Version control
-  ".git/",
-  ".svn/",
-  ".hg/",
-  ".bzr/",
-
-  // Environment files (often contain secrets)
-  ".env",
-  ".env.*",
-  "!.env.example",
-  "!.env.template",
-  "!.env.sample",
-
-  // Private keys and certificates
-  "*.pem",
-  "*.key",
-  "*.p12",
-  "*.pfx",
-  "*.keystore",
-  "*.jks",
-  "id_rsa",
-  "id_rsa.*",
-  "id_ed25519",
-  "id_ed25519.*",
-  "id_dsa",
-  "id_dsa.*",
-
-  // Cloud credentials
-  "credentials.json",
-  "service-account*.json",
-  "gcp-credentials*.json",
-  "aws-credentials",
-  ".aws/credentials",
-  ".aws/config",
-
-  // Generic secrets
-  ".secrets",
-  ".secrets/",
-  "*.secret",
-  ".credentials/",
-  "secrets.yaml",
-  "secrets.yml",
-  "secrets.json",
-
-  // Package manager auth
-  ".npmrc",
-  ".pypirc",
-  ".gem/credentials",
-  ".docker/config.json",
-
-  // IDE and editor
-  ".idea/",
-  ".vscode/",
-  "*.swp",
-  "*.swo",
-  "*.swn",
-  "*~",
-  ".project",
-  ".classpath",
-  ".settings/",
-  "*.sublime-workspace",
-  "*.sublime-project",
-  ".vs/",
-
-  // Operating system
-  ".DS_Store",
-  ".DS_Store?",
-  "._*",
-  ".Spotlight-V100",
-  ".Trashes",
-  "Thumbs.db",
-  "Thumbs.db:encryptable",
-  "desktop.ini",
-  "ehthumbs.db",
-  "ehthumbs_vista.db",
-
-  // Node.js
-  "node_modules/",
-  "npm-debug.log*",
-  "yarn-debug.log*",
-  "yarn-error.log*",
-  ".npm/",
-  ".yarn/cache/",
-  ".yarn/unplugged/",
-  ".pnp.*",
-
-  // Python
-  "__pycache__/",
-  "*.py[cod]",
-  "*$py.class",
-  ".Python",
-  "*.so",
-  ".venv/",
-  "venv/",
-  "env/",
-  "ENV/",
-  ".pytest_cache/",
-  ".mypy_cache/",
-  ".ruff_cache/",
-  ".tox/",
-  ".nox/",
-  "*.egg-info/",
-  ".eggs/",
-  "dist/",
-  "build/",
-  "develop-eggs/",
-  ".installed.cfg",
-  "*.manifest",
-  "*.spec",
-  "pip-log.txt",
-  "pip-delete-this-directory.txt",
-
-  // Java/JVM
-  "target/",
-  "*.class",
-  "*.jar",
-  "*.war",
-  "*.ear",
-  ".gradle/",
-  "gradle-app.setting",
-  ".gradletasknamecache",
-
-  // Go
-  "vendor/",
-
-  // Rust
-  "target/",
-  "Cargo.lock",
-
-  // Coverage and test reports
-  "coverage/",
-  ".coverage",
-  "htmlcov/",
-  ".nyc_output/",
-  "coverage.xml",
-  "*.cover",
-  ".hypothesis/",
-
-  // Logs
-  "*.log",
-  "logs/",
-
-  // Temporary files
-  "tmp/",
-  "temp/",
-  "*.tmp",
-  "*.temp",
-  "*.bak",
-  "*.backup",
-];

package/src/resources/ignore/match.ts

@@ -1,158 +0,0 @@
-// Faithful port of Go's path/filepath Match, used by the gitignore pattern
-// engine to match a single glob against a single path component.
-//
-// The separator is fixed to "/" (paths are normalized to forward slashes and
-// individual components never contain a separator). Matching operates on UTF-16
-// code units rather than runes — correct for the ASCII glob syntax gitignore
-// patterns use; exotic multi-byte classes are out of scope.
-//
-// Go returns ErrBadPattern for malformed patterns; every go-git caller treats
-// that as "no match", so `matchName` swallows the error and returns false.
-
-const SEPARATOR = "/";
-
-class BadPatternError extends Error {}
-
-/** Match `name` against the glob `pattern` (Go filepath.Match semantics). */
-export function matchName(pattern: string, name: string): boolean {
-  try {
-    return matchImpl(pattern, name);
-  } catch (err) {
-    if (err instanceof BadPatternError) return false;
-    throw err;
-  }
-}
-
-function matchImpl(pattern: string, name: string): boolean {
-  outer: while (pattern.length > 0) {
-    const [star, chunk, rest] = scanChunk(pattern);
-    pattern = rest;
-
-    if (star && chunk === "") {
-      // Trailing `*` matches the rest of the component (which has no separator).
-      return !name.includes(SEPARATOR);
-    }
-
-    const [t, ok] = matchChunk(chunk, name);
-    if (ok && (t.length === 0 || pattern.length > 0)) {
-      name = t;
-      continue;
-    }
-
-    if (star) {
-      for (let i = 0; i < name.length && name[i] !== SEPARATOR; i++) {
-        const [t2, ok2] = matchChunk(chunk, name.slice(i + 1));
-        if (ok2) {
-          if (pattern.length === 0 && t2.length > 0) continue;
-          name = t2;
-          continue outer;
-        }
-      }
-    }
-    return false;
-  }
-  return name.length === 0;
-}
-
-function scanChunk(pattern: string): [boolean, string, string] {
-  let star = false;
-  while (pattern.length > 0 && pattern[0] === "*") {
-    pattern = pattern.slice(1);
-    star = true;
-  }
-
-  let inrange = false;
-  let i = 0;
-  scan: for (i = 0; i < pattern.length; i++) {
-    switch (pattern[i]) {
-      case "\\":
-        if (i + 1 < pattern.length) i++;
-        break;
-      case "[":
-        inrange = true;
-        break;
-      case "]":
-        inrange = false;
-        break;
-      case "*":
-        if (!inrange) break scan;
-        break;
-    }
-  }
-  return [star, pattern.slice(0, i), pattern.slice(i)];
-}
-
-function matchChunk(chunk: string, s: string): [string, boolean] {
-  let failed = false;
-  while (chunk.length > 0) {
-    if (!failed && s.length === 0) failed = true;
-
-    const c = chunk[0];
-    if (c === "[") {
-      let r = "";
-      if (!failed) {
-        r = s[0];
-        s = s.slice(1);
-      }
-      chunk = chunk.slice(1);
-      let negated = false;
-      if (chunk.length > 0 && chunk[0] === "^") {
-        negated = true;
-        chunk = chunk.slice(1);
-      }
-      let match = false;
-      let nrange = 0;
-      for (;;) {
-        if (chunk.length > 0 && chunk[0] === "]" && nrange > 0) {
-          chunk = chunk.slice(1);
-          break;
-        }
-        let lo: string;
-        [lo, chunk] = getEsc(chunk);
-        let hi = lo;
-        if (chunk[0] === "-") {
-          [hi, chunk] = getEsc(chunk.slice(1));
-        }
-        if (lo <= r && r <= hi) match = true;
-        nrange++;
-      }
-      if (match === negated) failed = true;
-    } else if (c === "?") {
-      if (!failed) {
-        if (s[0] === SEPARATOR) failed = true;
-        s = s.slice(1);
-      }
-      chunk = chunk.slice(1);
-    } else if (c === "\\") {
-      chunk = chunk.slice(1);
-      if (chunk.length === 0) throw new BadPatternError("bad pattern");
-      if (!failed) {
-        if (chunk[0] !== s[0]) failed = true;
-        s = s.slice(1);
-      }
-      chunk = chunk.slice(1);
-    } else {
-      if (!failed) {
-        if (chunk[0] !== s[0]) failed = true;
-        s = s.slice(1);
-      }
-      chunk = chunk.slice(1);
-    }
-  }
-  if (failed) return ["", false];
-  return [s, true];
-}
-
-function getEsc(chunk: string): [string, string] {
-  if (chunk.length === 0 || chunk[0] === "-" || chunk[0] === "]") {
-    throw new BadPatternError("bad pattern");
-  }
-  if (chunk[0] === "\\") {
-    chunk = chunk.slice(1);
-    if (chunk.length === 0) throw new BadPatternError("bad pattern");
-  }
-  const r = chunk[0];
-  const nchunk = chunk.slice(1);
-  if (nchunk.length === 0) throw new BadPatternError("bad pattern");
-  return [r, nchunk];
-}

package/src/resources/ignore/pattern.ts

@@ -1,131 +0,0 @@
-// Faithful port of go-git's plumbing/format/gitignore Pattern (ParsePattern +
-// Match). This is what gives `push` its exact gitignore semantics: domain
-// scoping, directory-only patterns, single-name vs glob matching, and the
-// `**` zero-to-many-directories wildcard.
-
-import { matchName } from "./match.js";
-
-export enum MatchResult {
-  NoMatch = 0,
-  Exclude = 1,
-  Include = 2,
-}
-
-const INCLUSION_PREFIX = "!";
-const ZERO_TO_MANY = "**";
-const DIR_SEP = "/";
-
-export interface Pattern {
-  /** Whether this is a negation (`!`) pattern — needed for source ordering. */
-  readonly inclusion: boolean;
-  match(path: readonly string[], isDir: boolean): MatchResult;
-}
-
-class GitignorePattern implements Pattern {
-  readonly inclusion: boolean;
-  private readonly domain: readonly string[];
-  private readonly parts: readonly string[];
-  private readonly dirOnly: boolean;
-  private readonly isGlob: boolean;
-
-  constructor(domain: readonly string[], parts: readonly string[], inclusion: boolean, dirOnly: boolean, isGlob: boolean) {
-    this.domain = domain;
-    this.parts = parts;
-    this.inclusion = inclusion;
-    this.dirOnly = dirOnly;
-    this.isGlob = isGlob;
-  }
-
-  match(path: readonly string[], isDir: boolean): MatchResult {
-    const matchResult = this.inclusion ? MatchResult.Include : MatchResult.Exclude;
-
-    if (path.length <= this.domain.length) return MatchResult.NoMatch;
-    for (let i = 0; i < this.domain.length; i++) {
-      if (path[i] !== this.domain[i]) return MatchResult.NoMatch;
-    }
-
-    const scoped = path.slice(this.domain.length);
-    const matched = this.isGlob ? this.globMatch(scoped, isDir) : this.simpleNameMatch(scoped, isDir);
-    return matched ? matchResult : MatchResult.NoMatch;
-  }
-
-  private simpleNameMatch(path: readonly string[], isDir: boolean): boolean {
-    for (let i = 0; i < path.length; i++) {
-      if (!matchName(this.parts[0], path[i])) continue;
-      if (this.dirOnly && !isDir && i === path.length - 1) return false;
-      return true;
-    }
-    return false;
-  }
-
-  private globMatch(path: readonly string[], isDir: boolean): boolean {
-    let matched = false;
-    let canTraverse = false;
-    let remaining = path;
-
-    for (let i = 0; i < this.parts.length; i++) {
-      const part = this.parts[i];
-      if (part === "") {
-        canTraverse = false;
-        continue;
-      }
-      if (part === ZERO_TO_MANY) {
-        if (i === this.parts.length - 1) break;
-        canTraverse = true;
-        continue;
-      }
-      if (part.includes(ZERO_TO_MANY)) return false;
-      if (remaining.length === 0) return false;
-
-      if (canTraverse) {
-        canTraverse = false;
-        for (;;) {
-          if (remaining.length === 0) {
-            matched = false;
-            break;
-          }
-          const e = remaining[0];
-          remaining = remaining.slice(1);
-          if (matchName(part, e)) {
-            matched = true;
-            break;
-          }
-        }
-      } else {
-        if (!matchName(part, remaining[0])) return false;
-        matched = true;
-        remaining = remaining.slice(1);
-      }
-    }
-
-    if (matched && this.dirOnly && !isDir && remaining.length === 0) {
-      matched = false;
-    }
-    return matched;
-  }
-}
-
-/** Parse a gitignore pattern string into a matchable Pattern (go-git parity). */
-export function parsePattern(raw: string, domain: readonly string[]): Pattern {
-  let p = raw;
-  let inclusion = false;
-
-  if (p.startsWith(INCLUSION_PREFIX)) {
-    inclusion = true;
-    p = p.slice(1);
-  }
-
-  if (!p.endsWith("\\ ")) {
-    p = p.replace(/ +$/, "");
-  }
-
-  let dirOnly = false;
-  if (p.endsWith(DIR_SEP)) {
-    dirOnly = true;
-    p = p.slice(0, -1);
-  }
-
-  const isGlob = p.includes(DIR_SEP);
-  const parts = p.split(DIR_SEP);
-  return new GitignorePattern(domain, parts, inclusion, dirOnly, isGlob);
-}