@lmctl-ai/lmctl 0.2.71 → 0.2.73

package/examples/git_summary.lms

@@ -0,0 +1,8 @@
+// Usage: lmscript git_summary.lms [repository-directory]
+// The shipped example resolves its module relative to this file, not cwd.
+import "../modules/git.lms";
+dir = len(ARGV)>0 ? ARGV[0] : Directory;
+state = git.status(dir);
+println(json_stringify({root:git.root(dir),branch:state.branch,
+  clean:git.is_clean(dir),staged:state.staged,unstaged:state.unstaged,
+  untracked:state.untracked,conflicted:state.conflicted,latest:git.log(dir,3)}));

package/modules/git.lms

@@ -0,0 +1,167 @@
+// Git CLI module. Importing declares functions only; it runs no commands.
+// Success values: root/branch/remote_url/rev_parse strings (branch null when
+// detached); status map with path lists and rename maps; log list of maps;
+// diff_stat map {files,added,removed,binary}; is_clean boolean.
+// status uses porcelain v2 -z; staged/unstaged include conflict paths, with a
+// separate conflicted list. Rename maps preserve source and destination.
+// log subject is the full commit message (including body/newlines), minus its
+// terminal LF, rather than Git's flattened %s. n must be 0..10000.
+// diff_stat compares rev to index+worktree, excludes untracked paths and
+// reports renames as delete/add (--no-renames); binary counts are null.
+// Command failures throw via require with argv, exit/signal and stderr tail.
+// Launch errors (e.g. absent git) are loud system errors, with no process exit.
+// argv execution and --end-of-options protect user paths/revisions. Query
+// commands: no explicit fetch/push, no commit, no checkout, no import-time effects.
+// Git configuration/attributes/environment remain trusted; status/diff can run
+// clean filters. Error URLs are redacted; successful remote URLs remain data.
+package git;
+
+fn _line(text) {
+  if (ends_with(text, "\n")) { return slice(text, 0, len(text)-1); }
+  return text;
+}
+fn _redact(text) {
+  safe = regex_replace(text, "([a-zA-Z][a-zA-Z0-9+.-]*://)[^\\s/@]+@", "$1<redacted>@", "g");
+  return regex_replace(safe, "([?&](?:access_token|token|password|passwd|api_key)=)[^&\\s\"'<>]+", "$1<redacted>", "gi");
+}
+fn _argv(dir, args) {
+  require(is_string(dir) && len(dir)>0, "git: directory must be a nonempty string");
+  require(index_of(dir, from_char_code(0))<0, "git: directory must not contain NUL");
+  for (arg in args) { require(is_string(arg) && index_of(arg, from_char_code(0))<0, "git: arguments must be NUL-free strings"); }
+  return concat(["git", "--no-pager", "--no-optional-locks", "-C", abs_path(dir),
+    "-c", "color.ui=false", "-c", "core.quotePath=false", "-c", "core.fsmonitor=false"], args);
+}
+fn _checked(argv, result) {
+  tail = join(slice(split(_line(result.stderr), "\n"), -12), "\n");
+  require(result.code == 0 && !result.timed_out,
+    _redact(f"git command {json_stringify(argv)} failed (exit {str(result.code)}, signal {str(result.signal)}): {tail}"));
+  return result.stdout;
+}
+fn _run(dir, args) {
+  argv = _argv(dir, args);
+  result = system(argv);
+  return _checked(argv, result);
+}
+fn _fields(record, number) {
+  fields = [];
+  rest = record;
+  while (len(fields) < number) {
+    cut = index_of(rest, " ");
+    require(cut >= 0, "git: malformed porcelain v2 record");
+    push(fields, slice(rest, 0, cut));
+    rest = slice(rest, cut+1);
+  }
+  return {fields: fields, path: rest};
+}
+fn _parse_status(text) {
+  result = {branch: null, upstream: null, detached: false, unborn: false,
+    ahead: 0, behind: 0, staged: [], unstaged: [], untracked: [], conflicted: [], renamed: []};
+  records = split(text, from_char_code(0));
+  i = 0;
+  head_seen = false;
+  oid_seen = false;
+  while (i < len(records)) {
+    record = records[i];
+    if (starts_with(record, "# branch.head ")) {
+      head_seen = true;
+      name = slice(record, len("# branch.head "));
+      result.detached = name == "(detached)";
+      if (!result.detached) { result.branch = name; }
+    } else if (starts_with(record, "# branch.oid ")) {
+      oid_seen = true;
+      result.unborn = slice(record, len("# branch.oid ")) == "(initial)";
+    } else if (starts_with(record, "# branch.upstream ")) {
+      result.upstream = slice(record, len("# branch.upstream "));
+    } else if (starts_with(record, "# branch.ab ")) {
+      counts = split(slice(record, len("# branch.ab ")), " ");
+      require(len(counts)==2, "git: malformed ahead/behind record");
+      result.ahead = num(slice(counts[0], 1));
+      result.behind = num(slice(counts[1], 1));
+    } else if (starts_with(record, "? ")) {
+      push(result.untracked, slice(record, 2));
+    } else if (starts_with(record, "1 ") || starts_with(record, "2 ") || starts_with(record, "u ")) {
+      rename = starts_with(record, "2 ");
+      conflict = starts_with(record, "u ");
+      number = conflict ? 10 : (rename ? 9 : 8);
+      entry = _fields(record, number);
+      xy = entry.fields[1];
+      if (char_at(xy, 0) != ".") { push(result.staged, entry.path); }
+      if (char_at(xy, 1) != ".") { push(result.unstaged, entry.path); }
+      if (conflict) { push(result.conflicted, entry.path); }
+      if (rename) {
+        i = i+1;
+        require(i < len(records)-1, "git: missing original path in rename record");
+        push(result.renamed, {from: records[i], to: entry.path, status: xy});
+      }
+    } else {
+      require(record=="" || starts_with(record,"# "), "git: unknown porcelain v2 record");
+    }
+    i = i+1;
+  }
+  require(head_seen && oid_seen, "git.status: missing porcelain branch headers");
+  return result;
+}
+fn status(dir) {
+  state = _parse_status(_run(dir, ["status", "--porcelain=v2", "-z", "--branch", "--untracked-files=all", "--renames"]));
+  if (state.detached) {
+    // The valid branch name (detached) has the same porcelain spelling.
+    argv = _argv(dir, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    result = system(argv);
+    if (result.code==0) { state.branch = _line(_checked(argv,result)); state.detached = false; }
+    else if (!(result.code==1 && result.stderr=="" && !result.timed_out)) { _checked(argv,result); }
+  }
+  return state;
+}
+fn root(dir) { return _line(_run(dir, ["rev-parse", "--show-toplevel"])); }
+fn branch(dir) { return status(dir).branch; }
+fn is_clean(dir) {
+  state = status(dir);
+  return len(state.staged)+len(state.unstaged)+len(state.untracked)+len(state.conflicted)==0;
+}
+fn rev_parse(dir, rev) {
+  require(is_string(rev) && len(rev)>0, "git.rev_parse: revision must be a nonempty string");
+  return _line(_run(dir, ["rev-parse", "--verify", "--end-of-options", rev]));
+}
+fn remote_url(dir) { return _line(_run(dir, ["remote", "get-url", "--", "origin"])); }
+fn log(dir, n) {
+  require(is_number(n) && n>=0 && n<=10000 && n==round(n), "git.log: n must be an integer from 0 to 10000");
+  // Verify HEAD without scanning the worktree or invoking its clean filters.
+  argv = _argv(dir, ["rev-parse", "--verify", "--quiet", "--end-of-options", "HEAD"]);
+  head = system(argv);
+  if (head.code==1 && head.stderr=="" && !head.timed_out) { return []; }
+  _checked(argv, head);
+  if (n==0) { return []; }
+  text = _run(dir, ["log", "--no-show-signature", "--encoding=UTF-8", "-n", str(n), "--format=%H%x00%an%x00%aI%x00%B", "-z", "--"]);
+  fields = split(text, from_char_code(0));
+  require(len(fields)>1 && (len(fields)-1)%4==0, "git: malformed NUL log records");
+  entries = [];
+  i = 0;
+  while (i < len(fields)-1) {
+    date = fields[i+2];
+    // Newer git prints UTC as Z, older git as +00:00: one stable spelling for every git version.
+    if (ends_with(date, "Z")) { date = slice(date, 0, len(date)-1) + "+00:00"; }
+    push(entries, {hash: fields[i], author: fields[i+1], date: date, subject: _line(fields[i+3])});
+    i = i+4;
+  }
+  return entries;
+}
+fn diff_stat(dir, rev) {
+  hash = rev_parse(dir, rev);
+  text = _run(dir, ["diff", "--numstat", "-z", "--no-renames", "--no-ext-diff", "--no-textconv", hash, "--"]);
+  result = {files: [], added: 0, removed: 0, binary: 0};
+  for (record in split(text, from_char_code(0))) {
+    if (record != "") {
+      first = index_of(record, "\t");
+      second = index_of(record, "\t", first+1);
+      require(first>=0 && second>first, "git: malformed numstat record");
+      added = slice(record, 0, first);
+      removed = slice(record, first+1, second);
+      binary = added=="-" && removed=="-";
+      path = slice(record, second+1);
+      push(result.files, {path: path, added: binary ? null : num(added), removed: binary ? null : num(removed), binary: binary});
+      if (binary) { result.binary = result.binary+1; }
+      else { result.added = result.added+num(added); result.removed = result.removed+num(removed); }
+    }
+  }
+  return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lmctl-ai/lmctl",
-  "version": "0.2.71",
+  "version": "0.2.73",
   "description": "A provider-agnostic control plane for teams of AI coding agents — across providers, with independent review and durable memory.",
   "type": "module",
   "homepage": "https://lmctl.com",
@@ -33,7 +33,8 @@
     "THIRD_PARTY_NOTICES.md",
     "README.md",
     "CHANGELOG.md",
-    "examples/"
+    "examples/",
+    "modules/git.lms"
   ],
   "engines": {
     "node": ">=24.15.0"