grepmax 0.16.1 → 0.16.3

package/dist/lib/utils/project-registry.js

@@ -48,6 +48,8 @@ exports.getProject = getProject;
 exports.removeProject = removeProject;
 exports.getParentProject = getParentProject;
 exports.getChildProjects = getChildProjects;
+exports.resolveRootOrExit = resolveRootOrExit;
+exports.resolveProjectRoot = resolveProjectRoot;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
@@ -126,3 +128,44 @@ function getChildProjects(root) {
     const prefix = root.endsWith("/") ? root : `${root}/`;
     return loadRegistry().filter((e) => e.root !== root && e.root.startsWith(prefix));
 }
+/**
+ * Resolve a `--root` argument with cwd fallback, printing the helper's
+ * error message and setting process.exitCode = 1 on failure. Returns
+ * null when the caller should bail out. Used at command entry points.
+ */
+function resolveRootOrExit(arg) {
+    if (!arg)
+        return process.cwd();
+    try {
+        return resolveProjectRoot(arg);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+        return null;
+    }
+}
+/**
+ * Resolve a `--root` argument that may be either a path or a registered
+ * project name. Throws on no-match or duplicate-name so callers can
+ * report a uniform error.
+ */
+function resolveProjectRoot(arg) {
+    if (arg.includes("/") || arg.includes("\\"))
+        return path.resolve(arg);
+    const resolved = path.resolve(arg);
+    if (fs.existsSync(resolved))
+        return resolved;
+    const matches = loadRegistry().filter((p) => p.name === arg);
+    if (matches.length === 1)
+        return matches[0].root;
+    if (matches.length === 0) {
+        const all = loadRegistry();
+        const list = all.length > 0
+            ? all.map((p) => `  ${p.name.padEnd(24)} ${p.root}`).join("\n")
+            : "  (none registered)";
+        throw new Error(`No registered project named "${arg}".\nAvailable:\n${list}`);
+    }
+    const paths = matches.map((p) => `  ${p.root}`).join("\n");
+    throw new Error(`Multiple registered projects named "${arg}":\n${paths}\nPass an absolute path to disambiguate.`);
+}

package/dist/lib/utils/scope-filter.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveScope = resolveScope;
+exports.buildScopeWhere = buildScopeWhere;
+const path = __importStar(require("node:path"));
+const filter_builder_1 = require("./filter-builder");
+function toArray(value) {
+    if (value === undefined)
+        return [];
+    const arr = Array.isArray(value) ? value : [value];
+    // Support comma-separated values within each occurrence so agents can pass
+    // either `--in a --in b` or `--in a,b` interchangeably.
+    return arr
+        .flatMap((v) => v.split(","))
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+function joinSubpath(projectRoot, sub) {
+    const rootWithSlash = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
+    if (path.isAbsolute(sub))
+        return sub.endsWith("/") ? sub : `${sub}/`;
+    if (sub.startsWith(rootWithSlash))
+        return sub.endsWith("/") ? sub : `${sub}/`;
+    const joined = path.join(rootWithSlash, sub);
+    return joined.endsWith("/") ? joined : `${joined}/`;
+}
+function resolveScope(opts) {
+    const { projectRoot } = opts;
+    const ins = toArray(opts.in);
+    const excludes = toArray(opts.exclude);
+    const projectPrefix = projectRoot.endsWith("/")
+        ? projectRoot
+        : `${projectRoot}/`;
+    const inPrefixesAll = ins.map((v) => joinSubpath(projectRoot, v));
+    const excludePrefixes = excludes.map((v) => joinSubpath(projectRoot, v));
+    // Collapse a single --in into pathPrefix to keep WHERE clauses simple.
+    if (inPrefixesAll.length === 1) {
+        return {
+            pathPrefix: inPrefixesAll[0],
+            inPrefixes: [],
+            excludePrefixes,
+        };
+    }
+    return {
+        pathPrefix: projectPrefix,
+        inPrefixes: inPrefixesAll,
+        excludePrefixes,
+    };
+}
+/**
+ * Compose a SQL WHERE clause that AND-applies the resolved scope to an
+ * existing condition. Used by symbol commands that build their own table
+ * queries (peek/extract/similar/related) instead of going through
+ * Searcher.buildWhereClause or GraphBuilder.scopeWhere.
+ */
+function buildScopeWhere(scope, condition) {
+    const parts = [];
+    if (condition)
+        parts.push(condition);
+    parts.push(`path LIKE '${(0, filter_builder_1.escapeSqlString)(scope.pathPrefix)}%'`);
+    for (const ex of scope.excludePrefixes) {
+        parts.push(`path NOT LIKE '${(0, filter_builder_1.escapeSqlString)(ex)}%'`);
+    }
+    if (scope.inPrefixes.length > 0) {
+        const ors = scope.inPrefixes
+            .map((p) => `path LIKE '${(0, filter_builder_1.escapeSqlString)(p)}%'`)
+            .join(" OR ");
+        parts.push(`(${ors})`);
+    }
+    return parts.join(" AND ");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.16.1",
+  "version": "0.16.3",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",

package/plugins/grepmax/skills/grepmax/SKILL.md

@@ -125,9 +125,18 @@ gmax related src/lib/index/syncer.ts       # dependencies + dependents
 gmax related src/lib/index/syncer.ts --root ~/project
 ```
 
-### Recent changes — `gmax recent`
+### Commit history — `gmax log <path-or-symbol>`
 ```
-gmax recent                                # recently modified files
+gmax log src/lib/auth.ts                   # commits touching this file
+gmax log src/lib/                          # commits touching this directory
+gmax log handleAuth                        # commits across all files defining the symbol
+gmax log handleAuth --in src/              # restrict symbol resolution to a sub-path
+gmax log src/lib/auth.ts --limit 5         # last 5 commits
+gmax log src/lib/auth.ts --from main       # commits since main (range main..HEAD)
+gmax log src/lib/auth.ts --since "2 weeks ago"
+gmax log src/lib/auth.ts --author Robert
+gmax log src/lib/auth.ts --no-follow       # disable rename tracking (default: on for files)
+gmax log src/lib/auth.ts --agent           # TSV: hash\tisoDate\tauthor\tsubject\tfilesChanged\tins\tdel\ttouchedFiles
 ```
 
 ### Symbols — `gmax symbols`
@@ -137,15 +146,6 @@ gmax symbols auth -p src/ --root ~/proj    # filter by name, path, project
 gmax symbols --agent                       # compact: symbol\tpath:line\tcount
 ```
 
-### Diff — `gmax diff [ref]`
-```
-gmax diff                              # uncommitted changes
-gmax diff HEAD~5                       # last 5 commits
-gmax diff main                         # branch changes vs main
-gmax diff main --query "auth changes"  # semantic search within changed files
-gmax diff --agent                      # compact output
-```
-
 ### Test — `gmax test <symbol|file>`
 ```
 gmax test handleAuth                   # tests calling handleAuth