@agentxm/extension-sources 0.28.4 → 0.28.5

package/dist/src/errors.d.ts

@@ -82,7 +82,7 @@ export declare class SourceNetworkFailure extends SourceNetworkFailure_base<{
 }> {
 }
 /** The git subprocess operations this package performs. */
-export type GitOperation = "clone" | "get-commit-sha" | "get-tree-sha";
+export type GitOperation = "clone" | "get-commit-sha" | "get-tree-sha" | "compare-directory-to-head";
 declare const GitOperationFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "GitOperationFailed";
 } & Readonly<A>;

package/dist/src/git/directory-comparison.d.ts

@@ -0,0 +1,19 @@
+import * as ServiceMap from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import type { GitOperationFailed } from "../errors.js";
+import type { GitDirectoryComparisonResult } from "./operations.js";
+/** Input material for comparing one directory with its enclosing Git HEAD. */
+export interface GitDirectoryComparisonInput {
+    readonly directory: string;
+    readonly currentPaths: ReadonlyArray<string>;
+}
+/** Git worktree comparison capability used by publication preflight. */
+export interface GitDirectoryComparisonService {
+    readonly compare: (input: GitDirectoryComparisonInput) => Effect.Effect<Option.Option<GitDirectoryComparisonResult>, GitOperationFailed>;
+}
+declare const GitDirectoryComparison_base: ServiceMap.ServiceClass<GitDirectoryComparison, "@agentxm/extension-sources/git/GitDirectoryComparison", GitDirectoryComparisonService>;
+export declare class GitDirectoryComparison extends GitDirectoryComparison_base {
+}
+export {};
+//# sourceMappingURL=directory-comparison.d.ts.map

package/dist/src/git/directory-comparison.js

@@ -0,0 +1,5 @@
+import * as ServiceMap from "effect/Context";
+import * as Option from "effect/Option";
+export class GitDirectoryComparison extends ServiceMap.Service()("@agentxm/extension-sources/git/GitDirectoryComparison") {
+}
+//# sourceMappingURL=directory-comparison.js.map

package/dist/src/git/operations.d.ts

@@ -7,6 +7,20 @@
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
 import { GitOperationFailed } from "../errors.js";
+/** One raw regular-file difference between a Git HEAD subtree and the working tree. */
+export interface GitDirectoryDifference {
+    readonly path: string;
+    readonly change: "added" | "modified" | "deleted";
+    readonly headObject?: string;
+    readonly workingObject?: string;
+}
+/** Git evidence for one directory, before feature-specific archive filtering. */
+export interface GitDirectoryComparisonResult {
+    readonly repositoryRoot: string;
+    readonly repositoryDirectory: string;
+    readonly headRevision?: string;
+    readonly differences: ReadonlyArray<GitDirectoryDifference>;
+}
 /**
  * Shallow clone a git repository (depth 1, single branch).
  * Significantly faster than a full clone for read-only use cases like skill discovery.
@@ -34,4 +48,24 @@ export declare const getCommitSha: (repoPath: string) => Effect.Effect<string, G
  * @experimental This API is unstable and may change without notice.
  */
 export declare const getTreeSha: (repoPath: string, subPath?: string) => Effect.Effect<string, GitOperationFailed, never>;
+/**
+ * Compare an exact set of current regular files with the corresponding Git
+ * HEAD subtree. The caller owns which current paths belong to its material
+ * boundary; deleted HEAD paths remain present in the returned difference set
+ * so that boundary can classify them too.
+ */
+export declare const compareDirectoryToHead: (repositoryRoot: string, directory: string, currentPaths: ReadonlyArray<string>) => Effect.Effect<{
+    repositoryRoot: string;
+    repositoryDirectory: string;
+    differences: {
+        path: string;
+        change: "added";
+    }[];
+    headRevision?: never;
+} | {
+    repositoryRoot: string;
+    repositoryDirectory: string;
+    headRevision: string;
+    differences: GitDirectoryDifference[];
+}, GitOperationFailed, Path.Path>;
 //# sourceMappingURL=operations.d.ts.map

package/dist/src/git/operations.js

@@ -33,6 +33,75 @@ const mapGitError = (operation, context) => (error) => {
         cause: error,
     });
 };
+const toPosixPath = (value, separator) => separator === "/" ? value : value.split(separator).join("/");
+const relativeTreePath = (repositoryDirectory, repositoryPath) => {
+    if (repositoryDirectory === ".")
+        return repositoryPath;
+    const prefix = `${repositoryDirectory}/`;
+    return repositoryPath.startsWith(prefix) ? repositoryPath.slice(prefix.length) : undefined;
+};
+const parseHeadBlobs = (output, repositoryDirectory) => {
+    const blobs = new Map();
+    for (const record of output.split("\0")) {
+        if (record.length === 0)
+            continue;
+        const separator = record.indexOf("\t");
+        if (separator < 0)
+            throw new Error(`Unexpected ls-tree output: ${record}`);
+        const [mode, objectType, objectId] = record.slice(0, separator).split(" ");
+        if (mode === undefined || objectType === undefined || objectId === undefined) {
+            throw new Error(`Unexpected ls-tree output: ${record}`);
+        }
+        if (objectType !== "blob" || !mode.startsWith("100"))
+            continue;
+        const path = relativeTreePath(repositoryDirectory, record.slice(separator + 1));
+        if (path !== undefined)
+            blobs.set(path, objectId);
+    }
+    return blobs;
+};
+const hashWorkingFiles = async (git, directory, paths) => {
+    if (paths.length === 0)
+        return new Map();
+    const workingBlobs = new Map();
+    for (let offset = 0; offset < paths.length; offset += 128) {
+        const batch = paths.slice(offset, offset + 128);
+        const output = await git.raw([
+            "hash-object",
+            "--no-filters",
+            "--",
+            ...batch.map((path) => `${directory}/${path}`),
+        ]);
+        const hashes = output.trimEnd().split("\n");
+        if (hashes.length !== batch.length) {
+            throw new Error(`Expected ${batch.length} working-tree hashes, received ${hashes.length}`);
+        }
+        for (const [index, path] of batch.entries()) {
+            const hash = hashes[index];
+            if (hash === undefined)
+                throw new Error(`Missing working-tree hash for '${path}'`);
+            workingBlobs.set(path, hash);
+        }
+    }
+    return workingBlobs;
+};
+const readHeadRevision = async (git) => {
+    try {
+        return (await git.revparse(["--verify", "HEAD"])).trim();
+    }
+    catch (cause) {
+        try {
+            const symbolicRef = (await git.raw(["symbolic-ref", "--quiet", "HEAD"])).trim();
+            const refObject = (await git.raw(["for-each-ref", "--format=%(objectname)", symbolicRef])).trim();
+            if (refObject.length === 0)
+                return undefined;
+            throw cause;
+        }
+        catch {
+            throw cause;
+        }
+    }
+};
 // -----------------------------------------------------------------------------
 // Git Operations
 // -----------------------------------------------------------------------------
@@ -98,4 +167,64 @@ export const getTreeSha = (repoPath, subPath = ".") => Effect.tryPromise({
     },
     catch: mapGitError("get-tree-sha", `Failed to get tree SHA for '${subPath}'`),
 }).pipe(Effect.withSpan("Git.getTreeSha"));
+/**
+ * Compare an exact set of current regular files with the corresponding Git
+ * HEAD subtree. The caller owns which current paths belong to its material
+ * boundary; deleted HEAD paths remain present in the returned difference set
+ * so that boundary can classify them too.
+ */
+export const compareDirectoryToHead = (repositoryRoot, directory, currentPaths) => Effect.gen(function* () {
+    const path = yield* Path.Path;
+    return yield* Effect.tryPromise({
+        try: async (signal) => {
+            const git = createGit(repositoryRoot, signal);
+            const repositoryDirectory = toPosixPath(path.relative(repositoryRoot, directory), path.sep);
+            const normalizedDirectory = repositoryDirectory.length === 0 ? "." : repositoryDirectory;
+            const headRevision = await readHeadRevision(git);
+            if (headRevision === undefined) {
+                return {
+                    repositoryRoot,
+                    repositoryDirectory: normalizedDirectory,
+                    differences: [...currentPaths]
+                        .sort((left, right) => left.localeCompare(right))
+                        .map((currentPath) => ({ path: currentPath, change: "added" })),
+                };
+            }
+            const treeOutput = await git.raw([
+                "ls-tree",
+                "-r",
+                "-z",
+                "--full-tree",
+                "HEAD",
+                "--",
+                normalizedDirectory,
+            ]);
+            const headBlobs = parseHeadBlobs(treeOutput, normalizedDirectory);
+            const workingBlobs = await hashWorkingFiles(git, directory, currentPaths);
+            const allPaths = [...new Set([...headBlobs.keys(), ...workingBlobs.keys()])].sort((left, right) => left.localeCompare(right));
+            const differences = allPaths.flatMap((currentPath) => {
+                const headObject = headBlobs.get(currentPath);
+                const workingObject = workingBlobs.get(currentPath);
+                if (headObject === workingObject)
+                    return [];
+                if (headObject === undefined) {
+                    return workingObject === undefined
+                        ? []
+                        : [{ path: currentPath, change: "added", workingObject }];
+                }
+                if (workingObject === undefined) {
+                    return [{ path: currentPath, change: "deleted", headObject }];
+                }
+                return [{ path: currentPath, change: "modified", headObject, workingObject }];
+            });
+            return {
+                repositoryRoot,
+                repositoryDirectory: normalizedDirectory,
+                headRevision,
+                differences,
+            };
+        },
+        catch: mapGitError("compare-directory-to-head", `Failed to compare '${directory}' with Git HEAD`),
+    });
+}).pipe(Effect.withSpan("Git.compareDirectoryToHead"));
 //# sourceMappingURL=operations.js.map

package/dist/src/index.d.ts

@@ -26,5 +26,6 @@ export { discoverExtensionPackages, inspectExtensionPackage, type DiscoveredExte
 export { acquireExternalSource, findExtensionPackagesFromSource, type AcquiredExternalSource, type ResolvedExtensionPackage, } from "./package-sources.js";
 export { fileUrlToPath } from "./file-url.js";
 export { findGitRoot, isGitManaged } from "./git/detect.js";
-export { getCommitSha, getTreeSha, shallowClone } from "./git/operations.js";
+export { compareDirectoryToHead, getCommitSha, getTreeSha, shallowClone, type GitDirectoryComparisonResult, type GitDirectoryDifference, } from "./git/operations.js";
+export { GitDirectoryComparison, type GitDirectoryComparisonInput, type GitDirectoryComparisonService, } from "./git/directory-comparison.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -31,5 +31,6 @@ export { acquireExternalSource, findExtensionPackagesFromSource, } from "./packa
 export { fileUrlToPath } from "./file-url.js";
 // Git acquisition
 export { findGitRoot, isGitManaged } from "./git/detect.js";
-export { getCommitSha, getTreeSha, shallowClone } from "./git/operations.js";
+export { compareDirectoryToHead, getCommitSha, getTreeSha, shallowClone, } from "./git/operations.js";
+export { GitDirectoryComparison, } from "./git/directory-comparison.js";
 //# sourceMappingURL=index.js.map

package/dist/src/live.d.ts

@@ -15,6 +15,7 @@ import * as Layer from "effect/Layer";
 import { AxmSkillCandidateGate } from "./axm-skill-gate.js";
 import { SourceHostProviders } from "./service.js";
 import { WorkspaceCatalog } from "./workspace-catalog.js";
+import { GitDirectoryComparison } from "./git/directory-comparison.js";
 /**
  * Live layer for SourceHostProviders.
  *
@@ -26,4 +27,6 @@ import { WorkspaceCatalog } from "./workspace-catalog.js";
  * @experimental This API is unstable and may change without notice.
  */
 export declare const SourceHostProvidersLive: Layer.Layer<SourceHostProviders, never, FileSystem.FileSystem | HttpClient.HttpClient | Path.Path | WorkspaceCatalog | AxmSkillCandidateGate>;
+/** Live local-Git comparison service. */
+export declare const GitDirectoryComparisonLive: Layer.Layer<GitDirectoryComparison, never, FileSystem.FileSystem | Path.Path>;
 //# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -23,6 +23,9 @@ import { createGitHostingSourceHostProvider } from "./providers/git-hosting.js";
 import { createLocalSourceHostProvider } from "./providers/local.js";
 import { buildCloneUrlFromSource, createRegistryMetaProvider, getOriginFromSource, SourceHostProviders, } from "./service.js";
 import { WorkspaceCatalog } from "./workspace-catalog.js";
+import { GitDirectoryComparison } from "./git/directory-comparison.js";
+import { compareDirectoryToHead } from "./git/operations.js";
+import { findGitRoot } from "./git/detect.js";
 // -----------------------------------------------------------------------------
 // Layer
 // -----------------------------------------------------------------------------
@@ -128,4 +131,16 @@ export const SourceHostProvidersLive = Layer.effect(SourceHostProviders, Effect.
     };
     return service;
 }));
+/** Live local-Git comparison service. */
+export const GitDirectoryComparisonLive = Layer.effect(GitDirectoryComparison, Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const platform = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
+    return {
+        compare: ({ directory, currentPaths }) => findGitRoot(directory).pipe(Effect.flatMap(Option.match({
+            onNone: () => Effect.succeed(Option.none()),
+            onSome: (repositoryRoot) => compareDirectoryToHead(repositoryRoot, directory, currentPaths).pipe(Effect.map(Option.some)),
+        })), Effect.provide(platform)),
+    };
+}));
 //# sourceMappingURL=live.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentxm/extension-sources",
-  "version": "0.28.4",
+  "version": "0.28.5",
   "description": "AXM extension-source integration: source locator routing over the contract grammar, host providers for Registry, GitHub, GitLab, Bitbucket, Azure Repos, generic Git, and local paths, convention and manifest package discovery, identifier resolution, and shallow git acquisition for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "type": "module",
   "license": "FSL-1.1-MIT",
@@ -18,10 +18,12 @@
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
+      "axm-source": "./src/index.ts",
       "default": "./dist/src/index.js"
     },
     "./live": {
       "types": "./dist/src/live.d.ts",
+      "axm-source": "./src/live.ts",
       "default": "./dist/src/live.js"
     }
   },
@@ -42,9 +44,9 @@
     "effect": "4.0.0-rc.112",
     "semver": "^7.8.5",
     "simple-git": "^3.36.0",
-    "@agentxm/extension-model": "^0.28.4",
-    "@agentxm/registry-client": "^0.28.4",
-    "@agentxm/registry-protocol": "^0.28.4"
+    "@agentxm/registry-client": "^0.28.5",
+    "@agentxm/extension-model": "^0.28.5",
+    "@agentxm/registry-protocol": "^0.28.5"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",