@first-tree-ai/context-tree 0.1.1 → 0.1.2

package/dist/{schemas-DyQ0V9Z3.mjs → schemas-BWM6Q6iz.mjs}

@@ -1,5 +1,6 @@
+import { isAbsolute } from "node:path";
 import { z } from "zod";
-import { parse } from "yaml";
+import { parse as parse$1 } from "yaml";
 //#region src/internal/value.ts
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -7,7 +8,7 @@ function isRecord(value) {
 //#endregion
 //#region src/internal/frontmatter.ts
 function parseYamlMapping(source) {
-	const value = parse(source);
+	const value = parse$1(source);
 	if (!isRecord(value)) throw new Error("frontmatter must be a YAML mapping");
 	return value;
 }
@@ -85,13 +86,25 @@ const VALIDATION_CODES = {
 	directorySymlinkUnsupported: "TREE_DIRECTORY_SYMLINK_UNSUPPORTED",
 	directorySymlinkPathEscape: "TREE_DIRECTORY_SYMLINK_PATH_ESCAPE"
 };
-const CLI_ERROR_CODES = { failed: "CONTEXT_TREE_FAILED" };
+const CLI_ERROR_CODES = {
+	ambiguousLink: "AMBIGUOUS_LINK",
+	corruptLink: "CORRUPT_LINK",
+	failed: "CONTEXT_TREE_FAILED",
+	noLink: "NO_LINK",
+	staleLink: "STALE_LINK"
+};
 function hasUnsafeCharacter(value) {
 	return [...value].some((character) => {
 		const code = character.codePointAt(0);
 		return code !== void 0 && (code <= 31 || code === 127 || code === 8232 || code === 8233);
 	});
 }
+const absoluteSingleLinePathSchema = z.string().superRefine((value, context) => {
+	if (!isAbsolute(value) || value.trim() !== value || hasUnsafeCharacter(value)) context.addIssue({
+		code: "custom",
+		message: "Paths must be absolute single-line values."
+	});
+});
 const credentialFreeRepositoryUrlSchema = z.string().superRefine((value, context) => {
 	if (value.trim() !== value || hasUnsafeCharacter(value) || value.includes("\\")) {
 		context.addIssue({
@@ -118,12 +131,19 @@ const credentialFreeRepositoryUrlSchema = z.string().superRefine((value, context
 		});
 	}
 });
+const githubRepositoryIdentitySchema = z.string().superRefine((value, context) => {
+	const parts = value.split("/");
+	const [owner, name] = parts;
+	if (parts.length !== 2 || owner === void 0 || name === void 0 || !/^[A-Za-z\d](?:[A-Za-z\d-]{0,37}[A-Za-z\d])?$/u.test(owner) || !/^[A-Za-z\d._-]{1,100}$/u.test(name) || name === "." || name === ".." || /\.git$/iu.test(name)) context.addIssue({
+		code: "custom",
+		message: "Repository must be an explicit GitHub OWNER/REPO identity."
+	});
+});
 const contextTreeRootNodeFrontmatterSchema = z.object({
 	schemaVersion: z.literal(1),
 	title: z.string().trim().min(1),
 	description: z.string().trim().min(1).optional(),
-	soft_links: z.array(z.string().trim().min(1)).min(1).optional(),
-	relatedRepositories: z.array(credentialFreeRepositoryUrlSchema).max(64).optional()
+	soft_links: z.array(z.string().trim().min(1)).min(1).optional()
 }).loose();
 const contextTreeRootNodeSchema = z.object({
 	frontmatter: contextTreeRootNodeFrontmatterSchema,
@@ -195,6 +215,55 @@ const scaffoldTreeResultSchema = z.object({
 	schemaVersion: z.literal(1),
 	verification: verifyTreeReportSchema
 }).strict();
+const contextTreeProjectIdentitySchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("git"),
+	origin: credentialFreeRepositoryUrlSchema
+}).strict(), z.object({
+	kind: z.literal("directory"),
+	path: absoluteSingleLinePathSchema
+}).strict()]);
+const contextTreeLinkSchema = z.object({
+	project: contextTreeProjectIdentitySchema,
+	tree: z.object({
+		path: absoluteSingleLinePathSchema,
+		repository: githubRepositoryIdentitySchema
+	}).strict()
+}).strict();
+const contextTreeLinkResultSchema = z.object({
+	link: contextTreeLinkSchema,
+	schemaVersion: z.literal(1)
+}).strict();
+const contextTreeRefreshResultSchema = z.object({
+	link: contextTreeLinkSchema,
+	defaultBranch: z.string().trim().min(1),
+	refreshed: z.boolean(),
+	schemaVersion: z.literal(1),
+	sha: z.string()
+}).strict();
+const contextTreeStageResultSchema = z.object({
+	link: contextTreeLinkSchema,
+	defaultBranch: z.string().trim().min(1),
+	baseSha: z.string(),
+	schemaVersion: z.literal(1),
+	taskBranch: z.string().trim().min(1),
+	worktreePath: z.string()
+}).strict();
+const contextTreeDiffResultSchema = z.object({
+	base: z.string(),
+	files: z.array(z.object({
+		path: z.string(),
+		status: z.enum([
+			"added",
+			"deleted",
+			"modified",
+			"renamed",
+			"untracked"
+		])
+	}).strict()).max(4096),
+	patch: z.string(),
+	schemaVersion: z.literal(1),
+	treePath: z.string()
+}).strict();
 const contextTreeCliErrorCodeSchema = z.enum(CLI_ERROR_CODES);
 const contextTreeCliErrorSchema = z.object({
 	code: contextTreeCliErrorCodeSchema,
@@ -206,4 +275,4 @@ const contextTreeCliErrorEnvelopeSchema = z.object({
 	schemaVersion: z.literal(1)
 }).strict();
 //#endregion
-export { isRecord as C, parseMarkdownFrontmatter as S, parseContextTreeRootNode as _, contextContentClassCountsSchema as a, validationCodeSchema as b, contextTreeCliErrorEnvelopeSchema as c, contextTreeReadChildSchema as d, contextTreeReadNodeSchema as f, credentialFreeRepositoryUrlSchema as g, contextTreeRootNodeSchema as h, VALIDATION_CODES as i, contextTreeCliErrorSchema as l, contextTreeRootNodeFrontmatterSchema as m, CONTEXT_TREE_ROOT_NODE_MAX_BYTES as n, contextContentClassSchema as o, contextTreeReadResultSchema as p, SCHEMA_VERSION as r, contextTreeCliErrorCodeSchema as s, CLI_ERROR_CODES as t, contextTreePolicySchema as u, scaffoldTreeResultSchema as v, verifyTreeReportSchema as x, treeValidationFindingSchema as y };
+export { isRecord as A, githubRepositoryIdentitySchema as C, validationCodeSchema as D, treeValidationFindingSchema as E, verifyTreeReportSchema as O, credentialFreeRepositoryUrlSchema as S, scaffoldTreeResultSchema as T, contextTreeReadResultSchema as _, contextContentClassCountsSchema as a, contextTreeRootNodeSchema as b, contextTreeCliErrorEnvelopeSchema as c, contextTreeLinkResultSchema as d, contextTreeLinkSchema as f, contextTreeReadNodeSchema as g, contextTreeReadChildSchema as h, VALIDATION_CODES as i, parseMarkdownFrontmatter as k, contextTreeCliErrorSchema as l, contextTreeProjectIdentitySchema as m, CONTEXT_TREE_ROOT_NODE_MAX_BYTES as n, contextContentClassSchema as o, contextTreePolicySchema as p, SCHEMA_VERSION as r, contextTreeCliErrorCodeSchema as s, CLI_ERROR_CODES as t, contextTreeDiffResultSchema as u, contextTreeRefreshResultSchema as v, parseContextTreeRootNode as w, contextTreeStageResultSchema as x, contextTreeRootNodeFrontmatterSchema as y };

package/dist/{schemas-BZkU14CI.d.mts → schemas-C4bs-FkC.d.mts}

@@ -25,15 +25,19 @@ declare const VALIDATION_CODES: {
   readonly directorySymlinkPathEscape: "TREE_DIRECTORY_SYMLINK_PATH_ESCAPE";
 };
 declare const CLI_ERROR_CODES: {
+  readonly ambiguousLink: "AMBIGUOUS_LINK";
+  readonly corruptLink: "CORRUPT_LINK";
   readonly failed: "CONTEXT_TREE_FAILED";
+  readonly noLink: "NO_LINK";
+  readonly staleLink: "STALE_LINK";
 };
 declare const credentialFreeRepositoryUrlSchema: z.ZodString;
+declare const githubRepositoryIdentitySchema: z.ZodString;
 declare const contextTreeRootNodeFrontmatterSchema: z.ZodObject<{
   schemaVersion: z.ZodLiteral<1>;
   title: z.ZodString;
   description: z.ZodOptional<z.ZodString>;
   soft_links: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  relatedRepositories: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>;
 declare const contextTreeRootNodeSchema: z.ZodObject<{
   frontmatter: z.ZodObject<{
@@ -41,7 +45,6 @@ declare const contextTreeRootNodeSchema: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     soft_links: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    relatedRepositories: z.ZodOptional<z.ZodArray<z.ZodString>>;
   }, z.core.$loose>;
   body: z.ZodString;
 }, z.core.$strip>;
@@ -256,13 +259,118 @@ declare const scaffoldTreeResultSchema: z.ZodObject<{
   }, z.core.$strict>;
 }, z.core.$strict>;
 type ScaffoldTreeResult = z.infer<typeof scaffoldTreeResultSchema>;
+declare const contextTreeProjectIdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"git">;
+  origin: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"directory">;
+  path: z.ZodString;
+}, z.core.$strict>], "kind">;
+type ContextTreeProjectIdentity = z.infer<typeof contextTreeProjectIdentitySchema>;
+declare const contextTreeLinkSchema: z.ZodObject<{
+  project: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"git">;
+    origin: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"directory">;
+    path: z.ZodString;
+  }, z.core.$strict>], "kind">;
+  tree: z.ZodObject<{
+    path: z.ZodString;
+    repository: z.ZodString;
+  }, z.core.$strict>;
+}, z.core.$strict>;
+type ContextTreeLink = z.infer<typeof contextTreeLinkSchema>;
+declare const contextTreeLinkResultSchema: z.ZodObject<{
+  link: z.ZodObject<{
+    project: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"git">;
+      origin: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      kind: z.ZodLiteral<"directory">;
+      path: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    tree: z.ZodObject<{
+      path: z.ZodString;
+      repository: z.ZodString;
+    }, z.core.$strict>;
+  }, z.core.$strict>;
+  schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strict>;
+type ContextTreeLinkResult = z.infer<typeof contextTreeLinkResultSchema>;
+declare const contextTreeRefreshResultSchema: z.ZodObject<{
+  link: z.ZodObject<{
+    project: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"git">;
+      origin: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      kind: z.ZodLiteral<"directory">;
+      path: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    tree: z.ZodObject<{
+      path: z.ZodString;
+      repository: z.ZodString;
+    }, z.core.$strict>;
+  }, z.core.$strict>;
+  defaultBranch: z.ZodString;
+  refreshed: z.ZodBoolean;
+  schemaVersion: z.ZodLiteral<1>;
+  sha: z.ZodString;
+}, z.core.$strict>;
+type ContextTreeRefreshResult = z.infer<typeof contextTreeRefreshResultSchema>;
+declare const contextTreeStageResultSchema: z.ZodObject<{
+  link: z.ZodObject<{
+    project: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      kind: z.ZodLiteral<"git">;
+      origin: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+      kind: z.ZodLiteral<"directory">;
+      path: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    tree: z.ZodObject<{
+      path: z.ZodString;
+      repository: z.ZodString;
+    }, z.core.$strict>;
+  }, z.core.$strict>;
+  defaultBranch: z.ZodString;
+  baseSha: z.ZodString;
+  schemaVersion: z.ZodLiteral<1>;
+  taskBranch: z.ZodString;
+  worktreePath: z.ZodString;
+}, z.core.$strict>;
+type ContextTreeStageResult = z.infer<typeof contextTreeStageResultSchema>;
+declare const contextTreeDiffResultSchema: z.ZodObject<{
+  base: z.ZodString;
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    status: z.ZodEnum<{
+      added: "added";
+      deleted: "deleted";
+      modified: "modified";
+      renamed: "renamed";
+      untracked: "untracked";
+    }>;
+  }, z.core.$strict>>;
+  patch: z.ZodString;
+  schemaVersion: z.ZodLiteral<1>;
+  treePath: z.ZodString;
+}, z.core.$strict>;
+type ContextTreeDiffResult = z.infer<typeof contextTreeDiffResultSchema>;
 declare const contextTreeCliErrorCodeSchema: z.ZodEnum<{
+  readonly ambiguousLink: "AMBIGUOUS_LINK";
+  readonly corruptLink: "CORRUPT_LINK";
   readonly failed: "CONTEXT_TREE_FAILED";
+  readonly noLink: "NO_LINK";
+  readonly staleLink: "STALE_LINK";
 }>;
 type ContextTreeCliErrorCode = z.infer<typeof contextTreeCliErrorCodeSchema>;
 declare const contextTreeCliErrorSchema: z.ZodObject<{
   code: z.ZodEnum<{
+    readonly ambiguousLink: "AMBIGUOUS_LINK";
+    readonly corruptLink: "CORRUPT_LINK";
     readonly failed: "CONTEXT_TREE_FAILED";
+    readonly noLink: "NO_LINK";
+    readonly staleLink: "STALE_LINK";
   }>;
   message: z.ZodString;
 }, z.core.$strict>;
@@ -270,7 +378,11 @@ type ContextTreeCliError = z.infer<typeof contextTreeCliErrorSchema>;
 declare const contextTreeCliErrorEnvelopeSchema: z.ZodObject<{
   error: z.ZodObject<{
     code: z.ZodEnum<{
+      readonly ambiguousLink: "AMBIGUOUS_LINK";
+      readonly corruptLink: "CORRUPT_LINK";
       readonly failed: "CONTEXT_TREE_FAILED";
+      readonly noLink: "NO_LINK";
+      readonly staleLink: "STALE_LINK";
     }>;
     message: z.ZodString;
   }, z.core.$strict>;
@@ -279,4 +391,4 @@ declare const contextTreeCliErrorEnvelopeSchema: z.ZodObject<{
 }, z.core.$strict>;
 type ContextTreeCliErrorEnvelope = z.infer<typeof contextTreeCliErrorEnvelopeSchema>;
 //#endregion
-export { credentialFreeRepositoryUrlSchema as A, contextTreeCliErrorSchema as C, contextTreeReadResultSchema as D, contextTreeReadNodeSchema as E, verifyTreeReportSchema as F, scaffoldTreeResultSchema as M, treeValidationFindingSchema as N, contextTreeRootNodeFrontmatterSchema as O, validationCodeSchema as P, contextTreeCliErrorEnvelopeSchema as S, contextTreeReadChildSchema as T, ValidationCode as _, ContextTreeCliError as a, contextContentClassSchema as b, ContextTreePolicy as c, ContextTreeReadResult as d, ContextTreeRootNode as f, VALIDATION_CODES as g, TreeValidationFinding as h, ContextContentClassCounts as i, parseContextTreeRootNode as j, contextTreeRootNodeSchema as k, ContextTreeReadChild as l, ScaffoldTreeResult as m, CONTEXT_TREE_ROOT_NODE_MAX_BYTES as n, ContextTreeCliErrorCode as o, SCHEMA_VERSION as p, ContextContentClass as r, ContextTreeCliErrorEnvelope as s, CLI_ERROR_CODES as t, ContextTreeReadNode as u, VerifyTreeReport as v, contextTreePolicySchema as w, contextTreeCliErrorCodeSchema as x, contextContentClassCountsSchema as y };
+export { contextTreeDiffResultSchema as A, contextTreeRootNodeSchema as B, ValidationCode as C, contextTreeCliErrorCodeSchema as D, contextContentClassSchema as E, contextTreeReadChildSchema as F, scaffoldTreeResultSchema as G, credentialFreeRepositoryUrlSchema as H, contextTreeReadNodeSchema as I, verifyTreeReportSchema as J, treeValidationFindingSchema as K, contextTreeReadResultSchema as L, contextTreeLinkSchema as M, contextTreePolicySchema as N, contextTreeCliErrorEnvelopeSchema as O, contextTreeProjectIdentitySchema as P, contextTreeRefreshResultSchema as R, VALIDATION_CODES as S, contextContentClassCountsSchema as T, githubRepositoryIdentitySchema as U, contextTreeStageResultSchema as V, parseContextTreeRootNode as W, ContextTreeRootNode as _, ContextTreeCliError as a, ScaffoldTreeResult as b, ContextTreeDiffResult as c, ContextTreePolicy as d, ContextTreeProjectIdentity as f, ContextTreeRefreshResult as g, ContextTreeReadResult as h, ContextContentClassCounts as i, contextTreeLinkResultSchema as j, contextTreeCliErrorSchema as k, ContextTreeLink as l, ContextTreeReadNode as m, CONTEXT_TREE_ROOT_NODE_MAX_BYTES as n, ContextTreeCliErrorCode as o, ContextTreeReadChild as p, validationCodeSchema as q, ContextContentClass as r, ContextTreeCliErrorEnvelope as s, CLI_ERROR_CODES as t, ContextTreeLinkResult as u, ContextTreeStageResult as v, VerifyTreeReport as w, TreeValidationFinding as x, SCHEMA_VERSION as y, contextTreeRootNodeFrontmatterSchema as z };

package/dist/schemas.d.mts

@@ -1,2 +1,2 @@
-import { A as credentialFreeRepositoryUrlSchema, C as contextTreeCliErrorSchema, D as contextTreeReadResultSchema, E as contextTreeReadNodeSchema, F as verifyTreeReportSchema, M as scaffoldTreeResultSchema, N as treeValidationFindingSchema, O as contextTreeRootNodeFrontmatterSchema, P as validationCodeSchema, S as contextTreeCliErrorEnvelopeSchema, T as contextTreeReadChildSchema, _ as ValidationCode, a as ContextTreeCliError, b as contextContentClassSchema, c as ContextTreePolicy, d as ContextTreeReadResult, f as ContextTreeRootNode, g as VALIDATION_CODES, h as TreeValidationFinding, i as ContextContentClassCounts, j as parseContextTreeRootNode, k as contextTreeRootNodeSchema, l as ContextTreeReadChild, m as ScaffoldTreeResult, n as CONTEXT_TREE_ROOT_NODE_MAX_BYTES, o as ContextTreeCliErrorCode, p as SCHEMA_VERSION, r as ContextContentClass, s as ContextTreeCliErrorEnvelope, t as CLI_ERROR_CODES, u as ContextTreeReadNode, v as VerifyTreeReport, w as contextTreePolicySchema, x as contextTreeCliErrorCodeSchema, y as contextContentClassCountsSchema } from "./schemas-BZkU14CI.mjs";
-export { CLI_ERROR_CODES, CONTEXT_TREE_ROOT_NODE_MAX_BYTES, ContextContentClass, ContextContentClassCounts, ContextTreeCliError, ContextTreeCliErrorCode, ContextTreeCliErrorEnvelope, ContextTreePolicy, ContextTreeReadChild, ContextTreeReadNode, ContextTreeReadResult, ContextTreeRootNode, SCHEMA_VERSION, ScaffoldTreeResult, TreeValidationFinding, VALIDATION_CODES, ValidationCode, VerifyTreeReport, contextContentClassCountsSchema, contextContentClassSchema, contextTreeCliErrorCodeSchema, contextTreeCliErrorEnvelopeSchema, contextTreeCliErrorSchema, contextTreePolicySchema, contextTreeReadChildSchema, contextTreeReadNodeSchema, contextTreeReadResultSchema, contextTreeRootNodeFrontmatterSchema, contextTreeRootNodeSchema, credentialFreeRepositoryUrlSchema, parseContextTreeRootNode, scaffoldTreeResultSchema, treeValidationFindingSchema, validationCodeSchema, verifyTreeReportSchema };
+import { A as contextTreeDiffResultSchema, B as contextTreeRootNodeSchema, C as ValidationCode, D as contextTreeCliErrorCodeSchema, E as contextContentClassSchema, F as contextTreeReadChildSchema, G as scaffoldTreeResultSchema, H as credentialFreeRepositoryUrlSchema, I as contextTreeReadNodeSchema, J as verifyTreeReportSchema, K as treeValidationFindingSchema, L as contextTreeReadResultSchema, M as contextTreeLinkSchema, N as contextTreePolicySchema, O as contextTreeCliErrorEnvelopeSchema, P as contextTreeProjectIdentitySchema, R as contextTreeRefreshResultSchema, S as VALIDATION_CODES, T as contextContentClassCountsSchema, U as githubRepositoryIdentitySchema, V as contextTreeStageResultSchema, W as parseContextTreeRootNode, _ as ContextTreeRootNode, a as ContextTreeCliError, b as ScaffoldTreeResult, c as ContextTreeDiffResult, d as ContextTreePolicy, f as ContextTreeProjectIdentity, g as ContextTreeRefreshResult, h as ContextTreeReadResult, i as ContextContentClassCounts, j as contextTreeLinkResultSchema, k as contextTreeCliErrorSchema, l as ContextTreeLink, m as ContextTreeReadNode, n as CONTEXT_TREE_ROOT_NODE_MAX_BYTES, o as ContextTreeCliErrorCode, p as ContextTreeReadChild, q as validationCodeSchema, r as ContextContentClass, s as ContextTreeCliErrorEnvelope, t as CLI_ERROR_CODES, u as ContextTreeLinkResult, v as ContextTreeStageResult, w as VerifyTreeReport, x as TreeValidationFinding, y as SCHEMA_VERSION, z as contextTreeRootNodeFrontmatterSchema } from "./schemas-C4bs-FkC.mjs";
+export { CLI_ERROR_CODES, CONTEXT_TREE_ROOT_NODE_MAX_BYTES, ContextContentClass, ContextContentClassCounts, ContextTreeCliError, ContextTreeCliErrorCode, ContextTreeCliErrorEnvelope, ContextTreeDiffResult, ContextTreeLink, ContextTreeLinkResult, ContextTreePolicy, ContextTreeProjectIdentity, ContextTreeReadChild, ContextTreeReadNode, ContextTreeReadResult, ContextTreeRefreshResult, ContextTreeRootNode, ContextTreeStageResult, SCHEMA_VERSION, ScaffoldTreeResult, TreeValidationFinding, VALIDATION_CODES, ValidationCode, VerifyTreeReport, contextContentClassCountsSchema, contextContentClassSchema, contextTreeCliErrorCodeSchema, contextTreeCliErrorEnvelopeSchema, contextTreeCliErrorSchema, contextTreeDiffResultSchema, contextTreeLinkResultSchema, contextTreeLinkSchema, contextTreePolicySchema, contextTreeProjectIdentitySchema, contextTreeReadChildSchema, contextTreeReadNodeSchema, contextTreeReadResultSchema, contextTreeRefreshResultSchema, contextTreeRootNodeFrontmatterSchema, contextTreeRootNodeSchema, contextTreeStageResultSchema, credentialFreeRepositoryUrlSchema, githubRepositoryIdentitySchema, parseContextTreeRootNode, scaffoldTreeResultSchema, treeValidationFindingSchema, validationCodeSchema, verifyTreeReportSchema };

package/dist/schemas.mjs

@@ -1,2 +1,2 @@
-import { _ as parseContextTreeRootNode, a as contextContentClassCountsSchema, b as validationCodeSchema, c as contextTreeCliErrorEnvelopeSchema, d as contextTreeReadChildSchema, f as contextTreeReadNodeSchema, g as credentialFreeRepositoryUrlSchema, h as contextTreeRootNodeSchema, i as VALIDATION_CODES, l as contextTreeCliErrorSchema, m as contextTreeRootNodeFrontmatterSchema, n as CONTEXT_TREE_ROOT_NODE_MAX_BYTES, o as contextContentClassSchema, p as contextTreeReadResultSchema, r as SCHEMA_VERSION, s as contextTreeCliErrorCodeSchema, t as CLI_ERROR_CODES, u as contextTreePolicySchema, v as scaffoldTreeResultSchema, x as verifyTreeReportSchema, y as treeValidationFindingSchema } from "./schemas-DyQ0V9Z3.mjs";
-export { CLI_ERROR_CODES, CONTEXT_TREE_ROOT_NODE_MAX_BYTES, SCHEMA_VERSION, VALIDATION_CODES, contextContentClassCountsSchema, contextContentClassSchema, contextTreeCliErrorCodeSchema, contextTreeCliErrorEnvelopeSchema, contextTreeCliErrorSchema, contextTreePolicySchema, contextTreeReadChildSchema, contextTreeReadNodeSchema, contextTreeReadResultSchema, contextTreeRootNodeFrontmatterSchema, contextTreeRootNodeSchema, credentialFreeRepositoryUrlSchema, parseContextTreeRootNode, scaffoldTreeResultSchema, treeValidationFindingSchema, validationCodeSchema, verifyTreeReportSchema };
+import { C as githubRepositoryIdentitySchema, D as validationCodeSchema, E as treeValidationFindingSchema, O as verifyTreeReportSchema, S as credentialFreeRepositoryUrlSchema, T as scaffoldTreeResultSchema, _ as contextTreeReadResultSchema, a as contextContentClassCountsSchema, b as contextTreeRootNodeSchema, c as contextTreeCliErrorEnvelopeSchema, d as contextTreeLinkResultSchema, f as contextTreeLinkSchema, g as contextTreeReadNodeSchema, h as contextTreeReadChildSchema, i as VALIDATION_CODES, l as contextTreeCliErrorSchema, m as contextTreeProjectIdentitySchema, n as CONTEXT_TREE_ROOT_NODE_MAX_BYTES, o as contextContentClassSchema, p as contextTreePolicySchema, r as SCHEMA_VERSION, s as contextTreeCliErrorCodeSchema, t as CLI_ERROR_CODES, u as contextTreeDiffResultSchema, v as contextTreeRefreshResultSchema, w as parseContextTreeRootNode, x as contextTreeStageResultSchema, y as contextTreeRootNodeFrontmatterSchema } from "./schemas-BWM6Q6iz.mjs";
+export { CLI_ERROR_CODES, CONTEXT_TREE_ROOT_NODE_MAX_BYTES, SCHEMA_VERSION, VALIDATION_CODES, contextContentClassCountsSchema, contextContentClassSchema, contextTreeCliErrorCodeSchema, contextTreeCliErrorEnvelopeSchema, contextTreeCliErrorSchema, contextTreeDiffResultSchema, contextTreeLinkResultSchema, contextTreeLinkSchema, contextTreePolicySchema, contextTreeProjectIdentitySchema, contextTreeReadChildSchema, contextTreeReadNodeSchema, contextTreeReadResultSchema, contextTreeRefreshResultSchema, contextTreeRootNodeFrontmatterSchema, contextTreeRootNodeSchema, contextTreeStageResultSchema, credentialFreeRepositoryUrlSchema, githubRepositoryIdentitySchema, parseContextTreeRootNode, scaffoldTreeResultSchema, treeValidationFindingSchema, validationCodeSchema, verifyTreeReportSchema };

package/docs/specification.md

@@ -16,17 +16,12 @@ It must contain non-empty prose and schema-version-1 frontmatter:
 schemaVersion: 1
 title: "Service Context"
 description: "Durable decisions shared across service domains."
-relatedRepositories:
-  - https://github.com/acme/service.git
 ---
 ```
 
-Root-only `schemaVersion` is required. Root-only `relatedRepositories` is
-optional, remains provider-neutral, and accepts at most 64
-credential-free HTTP(S), `ssh://`, or scp-style SSH references. It describes
-related source repositories; it does not identify the Context Tree repository.
-Neither root-only field is valid on domain nodes or Markdown leaves. A legacy
-`SCOPE.md` has no special meaning and is validated as an ordinary leaf.
+Root-only `schemaVersion` is required and is not valid on domain nodes or
+Markdown leaves. A legacy `SCOPE.md` has no special meaning and is validated as
+an ordinary leaf.
 
 ## Nodes and content classes
 
@@ -82,28 +77,68 @@ the root, schema version, validity, findings, and content-class counts. None
 includes a tree digest or per-entry digest. The Git commit SHA is recorded by
 the surrounding host Git workflow rather than computed by the core.
 
+`link` and `resolve` return a strict link result containing the
+project identity and tree `OWNER/REPO` plus a canonical absolute, single-line
+checkout path. Link
+failures distinguish `NO_LINK`, `AMBIGUOUS_LINK`,
+`CORRUPT_LINK`, and `STALE_LINK` from other CLI failures.
+
 ## Lifecycle
 
-Scaffolding creates exactly two files: root `NODE.md` and
-`.github/workflows/validate-context-tree.yml`. The workflow is pinned to the
-package version that generated it. Init takes canonical `OWNER/REPO` and an
+Scaffolding creates exactly four files: root `NODE.md`, root `AGENTS.md`, root
+`CLAUDE.md`, and `.github/workflows/validate-context-tree.yml`. `AGENTS.md`
+explains the tree's purpose, structure, authority, and write discipline to
+agents entering the repository. `CLAUDE.md` is a relative symlink to `AGENTS.md`
+so both instruction filenames expose the same packaged guidance. The workflow
+is pinned to the package version that generated it. Init takes canonical `OWNER/REPO` and an
 optional absent or empty destination. It requires Git, runs ordinary `git init`, and uses the
 unborn branch selected by Git's effective `init.defaultBranch` configuration or
 compiled fallback. The generated workflow filters pushes to that exact branch.
-The local tree title and default destination name come from `REPO`. The core and
-CLI perform no GitHub or credential operations.
-
-Reads take `agent_slug`, an existing checkout path, and `branch`. Writes take
-`agent_slug`, an existing fetch-only checkout path, and the authoritative
-`default_branch` publication target.
-The exact clean, non-symlink Git root and its credential-free GitHub `origin`
-form the authorization boundary. Reads refresh fast-forward-only, validate, and
-report the commit SHA; authorized stale reads stay read-only.
-
-Writes fetch the supplied default branch through that checkout and edit an
+The local tree title and default destination name come from `REPO`. Init
+configures a credential-free `https://github.com/OWNER/REPO.git` origin. Init
+records an unambiguous current project link only in the machine-local links
+file and never embeds the source-project association in the tree.
+The core and CLI perform no authenticated GitHub operations.
+
+Internal links live at `~/.context-tree/connections.json`. A link
+maps a normalized Git project origin or a real non-Git directory to canonical
+tree `OWNER/REPO` and checkout path. Git lookup also confirms that the project
+origin matches the local record; non-Git lookup includes descendants.
+Zero or multiple matches fail, and a project cannot link to different tree
+repositories. Explicit linking requires a clean exact Git root, safe GitHub
+origin, and complete tree verification. Init may
+automatically link only its exact new uncommitted scaffold. Resolve rejects symlinked,
+dirty, moved, mismatched-origin, and invalid-root candidates, but parses only
+root `NODE.md` rather than scanning all semantic content. Full verification is
+the responsibility of read and write after refresh.
+
+A moved checkout produces `STALE_LINK`; explicit linking may replace its
+path only after verifying the same stored tree repository and proving the prior
+path absent, no longer an exact checkout, or occupied by another repository. A
+second live checkout cannot replace the stored path, even when the stored
+checkout is dirty. Relinking the same canonical path is idempotent.
+
+Link setup selects or clones a verified checkout and writes only the local link
+record. It never mutates or publishes the Context Tree repository.
+
+Reads and writes take only `agent_slug`, sourced from authoritative task role
+instructions. They resolve the current project, then discover the live default
+branch using `git ls-remote --symref origin HEAD`; branches are never configured
+or cached. The exact clean, non-symlink Git root and its credential-free GitHub
+`origin` remain the authorization boundary. Resolution selects a candidate and
+does not replace full semantic verification. Reads refresh fast-forward-only,
+validate, and report the commit SHA; authorized stale reads stay read-only.
+
+The package root exports `linkProject`, `resolveLink`,
+`readContextTreePolicy`, `readTree`, `scaffoldTree`, and `verifyTree`.
+Project identification, URL normalization, and the links-file storage
+schema are internal. Public strict CLI result schemas remain available from
+the schemas entrypoint.
+
+Writes fetch the discovered default branch through that checkout and edit an
 isolated worktree. One source comes from task context, not an invocation
 argument, and scopes one write and commit. The base and result must validate;
-publication first uses a non-force direct push to the supplied default branch.
+publication first uses a non-force direct push to the discovered default branch.
 Concurrent updates are rebased, resolved from authorized evidence, and verified
 again with bounded retries. Explicit direct-push denial or exhausted retries
 uses a latest-base, conflict-free task-branch PR fallback that remains open.

package/examples/basic/NODE.md

@@ -2,8 +2,6 @@
 schemaVersion: 1
 title: "Example Context Tree"
 description: "A small valid Context Tree fixture."
-relatedRepositories:
-  - https://github.com/first-tree-ai/context-tree.git
 ---
 
 # Example Context Tree

package/hooks/hooks.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/session-start.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/session-start.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/session-start.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+let input;
+try {
+  input = JSON.parse(
+    await new Promise((resolve) => {
+      let source = "";
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => {
+        source += chunk;
+      });
+      process.stdin.on("end", () => resolve(source));
+    }),
+  );
+} catch {
+  process.exit(0);
+}
+
+if (typeof input !== "object" || input === null || Array.isArray(input) || typeof input.cwd !== "string") {
+  process.exit(0);
+}
+if (input.hook_event_name !== "SessionStart" && input.hook_event_name !== "SubagentStart") process.exit(0);
+
+const pluginRoot = process.env.PLUGIN_ROOT ?? process.env.CLAUDE_PLUGIN_ROOT;
+const packagedCli = pluginRoot === undefined ? undefined : join(pluginRoot, "dist", "cli", "index.mjs");
+if (packagedCli === undefined || !existsSync(packagedCli)) {
+  process.stdout.write(JSON.stringify({ systemMessage: "Context Tree setup warning: packaged CLI is unavailable." }));
+  process.exit(0);
+}
+const resolved = spawnSync(process.execPath, [packagedCli, "resolve", "--project-path", input.cwd], {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "ignore"],
+});
+let payload;
+try {
+  payload = JSON.parse(resolved.stdout);
+} catch {
+  process.stdout.write(JSON.stringify({ systemMessage: "Context Tree setup warning: packaged CLI is unavailable." }));
+  process.exit(0);
+}
+
+if (resolved.status !== 0) {
+  const code = payload?.error?.code;
+  if (code === "NO_LINK") process.exit(0);
+  if (["AMBIGUOUS_LINK", "CORRUPT_LINK", "STALE_LINK"].includes(code)) {
+    process.stdout.write(JSON.stringify({ systemMessage: `Context Tree setup warning: ${payload.error.message}` }));
+  }
+  process.exit(0);
+}
+
+const tree = payload?.link?.tree;
+if (typeof tree?.path !== "string" || typeof tree?.repository !== "string") process.exit(0);
+process.stdout.write(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: input.hook_event_name,
+      additionalContext: `Context Tree ${tree.repository} is linked at ${tree.path}. Use the Context Tree skills for task-relevant durable context.`,
+    },
+  }),
+);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@first-tree-ai/context-tree",
-  "version": "0.1.1",
-  "description": "Portable Context Tree schemas, tooling, and agent skills.",
+  "version": "0.1.2",
+  "description": "Context Tree plugin for Codex and Claude Code, with a CLI for shell automation.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
@@ -40,9 +40,14 @@
     }
   },
   "files": [
+    "plugin.json",
+    ".agents/plugins/marketplace.json",
+    ".claude-plugin",
+    ".codex-plugin",
     "dist",
     "docs",
     "examples",
+    "hooks",
     "skills",
     "policy",
     "templates",
@@ -50,12 +55,13 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsdown src/index.ts src/schemas.ts src/cli/index.ts --format esm --dts",
+    "build": "tsdown src/index.ts src/schemas.ts --format esm --dts && tsdown src/cli/index.ts --format esm --dts --out-dir dist/cli --no-clean --deps.alwaysBundle '/.*/'",
     "check": "biome check .",
     "format": "biome check --write .",
     "typecheck": "tsc --noEmit",
     "test": "pnpm build && vitest run",
-    "validate:skills": "vitest run tests/skills.test.ts",
+    "test:codex-plugin": "bash scripts/test-codex-plugin-local.sh",
+    "validate:skills": "vitest run tests/skills.test.ts tests/plugin.test.ts",
     "check:package": "pnpm build && publint && attw --pack . --profile esm-only && pnpm package:e2e",
     "package:e2e": "node scripts/package-e2e.mjs",
     "check:names": "vitest run tests/names.test.ts",

package/plugin.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "context-tree",
+  "version": "0.1.2",
+  "description": "Complete Context Tree plugin with linking, reading, durable writes, and a packaged CLI.",
+  "author": {
+    "name": "First Tree AI",
+    "url": "https://github.com/first-tree-ai"
+  },
+  "homepage": "https://github.com/first-tree-ai/context-tree",
+  "repository": "https://github.com/first-tree-ai/context-tree",
+  "license": "Apache-2.0",
+  "keywords": ["context-tree", "memory", "agents"]
+}

package/policy/context-tree-policy.md

@@ -123,6 +123,8 @@ title: "Short noun phrase"
 ---
 ```
 
+Only the root `NODE.md` must also include `schemaVersion`.
+
 Useful optional frontmatter: `description`, `soft_links`,
 `lastReviewed`, and `decisionLocksCode`. `lastReviewed` records an actual
 human review; update it only when that review is the concrete source for a