@treeseed/core 0.1.2

package/dist/styles/prose.css

@@ -0,0 +1,89 @@
+.prose-karyon {
+	color: var(--site-text);
+	font-size: 1.08rem;
+}
+
+.prose-karyon h1,
+.prose-karyon h2,
+.prose-karyon h3 {
+	color: var(--site-text);
+	line-height: 1.12;
+	font-weight: 700;
+}
+
+.prose-karyon h1 {
+	font-size: clamp(2.4rem, 5vw, 4.1rem);
+	margin-bottom: 1.2rem;
+	font-family: var(--font-serif);
+}
+
+.prose-karyon h2 {
+	font-size: clamp(1.85rem, 2.8vw, 2.5rem);
+	margin-top: 3.1rem;
+	margin-bottom: 1rem;
+}
+
+.prose-karyon h3 {
+	font-size: 1.32rem;
+	margin-top: 2rem;
+	margin-bottom: 0.7rem;
+}
+
+.prose-karyon p,
+.prose-karyon li {
+	color: var(--site-text-muted);
+	line-height: 1.85;
+}
+
+.prose-karyon p {
+	margin: 1rem 0 1.2rem;
+}
+
+.prose-karyon p + p {
+	margin-top: 1.35rem;
+}
+
+.prose-karyon a {
+	color: var(--site-accent-strong);
+	text-decoration: underline;
+	text-underline-offset: 0.16em;
+	font-weight: 600;
+}
+
+.prose-karyon strong {
+	color: var(--site-text);
+}
+
+.prose-karyon ul,
+.prose-karyon ol {
+	padding-left: 1.3rem;
+}
+
+.prose-karyon blockquote {
+	border-left: 4px solid var(--site-accent);
+	padding-left: 1rem;
+	color: var(--site-text-muted);
+}
+
+.prose-karyon code {
+	background: rgba(95, 141, 164, 0.12);
+	border: 1px solid rgba(95, 141, 164, 0.22);
+	border-radius: 0.5rem;
+	padding: 0.1rem 0.35rem;
+}
+
+.prose-karyon hr {
+	border-color: var(--site-border);
+	margin: 2.4rem 0;
+}
+
+.prose-karyon :where(table) {
+	width: 100%;
+	border-collapse: collapse;
+}
+
+.prose-karyon :where(th, td) {
+	border-bottom: 1px solid var(--site-border);
+	padding: 0.85rem 0.75rem;
+	text-align: left;
+}

package/dist/styles/tokens.css

@@ -0,0 +1,24 @@
+:root {
+	--site-bg: #f4ede0;
+	--site-bg-elevated: #ede4d2;
+	--site-bg-soft: #f8f3e9;
+	--site-panel: rgba(244, 237, 224, 0.86);
+	--site-panel-strong: #e7dcc8;
+	--site-border: rgba(88, 77, 61, 0.16);
+	--site-border-strong: rgba(104, 132, 98, 0.34);
+	--site-grid: rgba(132, 154, 132, 0.14);
+	--site-text: #2e261c;
+	--site-text-muted: #4d4638;
+	--site-text-soft: #6b665b;
+	--site-accent: #c7dbc4;
+	--site-accent-strong: #5f7c5f;
+	--site-accent-soft: #e9f0e5;
+	--site-blue: #86aac0;
+	--site-blue-strong: #456679;
+	--site-blue-soft: #e4eef3;
+	--site-warm: #d7b07b;
+	--site-warm-strong: #7c5a2d;
+	--site-shadow: 0 24px 56px rgba(75, 60, 32, 0.08);
+	--site-radius: 0.65rem;
+	--site-max: 76rem;
+}

package/dist/tenant/bridge.js

@@ -0,0 +1,5 @@
+import { loadTreeseedManifest } from "./config.js";
+const PROJECT_TENANT = loadTreeseedManifest();
+export {
+  PROJECT_TENANT
+};

package/dist/tenant/config.d.ts

@@ -0,0 +1,9 @@
+import type { TreeseedTenantConfig } from '../contracts';
+declare function resolveTenantRoot(): string;
+export declare function defineTreeseedTenant<T>(tenantConfig: T): T;
+export declare function loadTreeseedManifest(manifestPath?: string): TreeseedTenantConfig;
+export declare const loadTreeseedTenantManifest: typeof loadTreeseedManifest;
+export declare const resolveTreeseedTenantRoot: typeof resolveTenantRoot;
+export declare function getTenantContentRoot(tenantConfig: Pick<TreeseedTenantConfig, 'content'>, collectionName: string): string;
+export declare function tenantFeatureEnabled(tenantConfig: Pick<TreeseedTenantConfig, 'features'>, featureName: string): boolean;
+export {};

package/dist/tenant/config.js

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse as parseYaml } from "yaml";
+function resolvePackageRoot() {
+  const moduleUrl = typeof import.meta?.url === "string" ? import.meta.url : null;
+  if (!moduleUrl) {
+    return process.cwd();
+  }
+  return resolve(dirname(fileURLToPath(moduleUrl)), "../..");
+}
+const packageRoot = resolvePackageRoot();
+const packageFixtureRoot = resolve(packageRoot, ".fixtures", "treeseed-fixtures", "sites", "working-site");
+const explicitTenantRoot = process.env.TREESEED_TENANT_ROOT ? resolve(process.env.TREESEED_TENANT_ROOT) : null;
+function pathWithin(parent, candidate) {
+  const normalizedParent = resolve(parent);
+  const normalizedCandidate = resolve(candidate);
+  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}/`);
+}
+function collectTenantRootCandidates(start) {
+  const candidates = [];
+  let current = resolve(start);
+  while (true) {
+    candidates.push(
+      current,
+      resolve(current, ".fixtures", "treeseed-fixtures", "sites", "working-site"),
+      resolve(current, "fixture")
+    );
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return candidates;
+}
+function uniqueCandidates(entries) {
+  return [...new Set(entries.map((entry) => resolve(entry)))];
+}
+function tenantRootCandidates() {
+  const cwd = resolve(process.cwd());
+  const cwdCandidates = collectTenantRootCandidates(cwd);
+  const packageCandidates = collectTenantRootCandidates(packageRoot);
+  if (explicitTenantRoot) {
+    return uniqueCandidates([explicitTenantRoot, ...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
+  }
+  if (pathWithin(packageRoot, cwd)) {
+    return uniqueCandidates([packageFixtureRoot, ...cwdCandidates, ...packageCandidates]);
+  }
+  return uniqueCandidates([...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
+}
+function resolveTenantPath(manifestPath) {
+  if (existsSync(manifestPath)) {
+    return resolve(manifestPath);
+  }
+  const candidates = tenantRootCandidates().map((root) => resolve(root, manifestPath));
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve Treeseed tenant manifest at "${manifestPath}" from ${process.cwd()} or ${packageFixtureRoot}.`
+  );
+}
+function resolveTenantRoot() {
+  const candidates = tenantRootCandidates();
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, "src/manifest.yaml"))) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve a Treeseed tenant root from ${process.cwd()} or ${packageFixtureRoot}.`
+  );
+}
+function defineTreeseedTenant(tenantConfig) {
+  return tenantConfig;
+}
+function loadTreeseedManifest(manifestPath = "./src/manifest.yaml") {
+  const resolvedManifestPath = resolveTenantPath(manifestPath);
+  const tenantRoot = resolve(dirname(resolvedManifestPath), "..");
+  const parsed = parseYaml(readFileSync(resolvedManifestPath, "utf8"));
+  const tenantConfig = defineTreeseedTenant({
+    ...parsed,
+    siteConfigPath: resolve(tenantRoot, parsed.siteConfigPath),
+    content: Object.fromEntries(
+      Object.entries(parsed.content ?? {}).map(([collectionName, rootPath]) => [
+        collectionName,
+        resolve(tenantRoot, String(rootPath))
+      ])
+    ),
+    overrides: parsed.overrides ? {
+      pagesRoot: parsed.overrides.pagesRoot ? resolve(tenantRoot, parsed.overrides.pagesRoot) : void 0,
+      stylesRoot: parsed.overrides.stylesRoot ? resolve(tenantRoot, parsed.overrides.stylesRoot) : void 0,
+      componentsRoot: parsed.overrides.componentsRoot ? resolve(tenantRoot, parsed.overrides.componentsRoot) : void 0
+    } : void 0
+  });
+  Object.defineProperty(tenantConfig, "__tenantRoot", {
+    value: tenantRoot,
+    enumerable: false
+  });
+  return tenantConfig;
+}
+const loadTreeseedTenantManifest = loadTreeseedManifest;
+const resolveTreeseedTenantRoot = resolveTenantRoot;
+function getTenantContentRoot(tenantConfig, collectionName) {
+  const root = tenantConfig.content[collectionName];
+  if (!root) {
+    throw new Error(`Unknown tenant content collection: ${collectionName}`);
+  }
+  return root;
+}
+function tenantFeatureEnabled(tenantConfig, featureName) {
+  return tenantConfig.features?.[featureName] !== false;
+}
+export {
+  defineTreeseedTenant,
+  getTenantContentRoot,
+  loadTreeseedManifest,
+  loadTreeseedTenantManifest,
+  resolveTreeseedTenantRoot,
+  tenantFeatureEnabled
+};

package/dist/tenant/runtime-config.js

@@ -0,0 +1,20 @@
+import { readFileSync } from "node:fs";
+import { loadTreeseedManifest } from "./config.js";
+import { parseSiteConfig } from "../utils/site-config-schema.js";
+const injectedTenantConfig = typeof __TREESEED_TENANT_CONFIG__ !== "undefined" ? __TREESEED_TENANT_CONFIG__ : null;
+const injectedProjectRoot = typeof __TREESEED_PROJECT_ROOT__ !== "undefined" ? __TREESEED_PROJECT_ROOT__ : null;
+const injectedSiteConfig = typeof __TREESEED_SITE_CONFIG__ !== "undefined" ? __TREESEED_SITE_CONFIG__ : null;
+const RUNTIME_TENANT = injectedTenantConfig ?? loadTreeseedManifest();
+const RUNTIME_PROJECT_ROOT = injectedProjectRoot ?? process.cwd();
+const RUNTIME_SITE_CONFIG = injectedSiteConfig ?? (() => {
+  try {
+    return parseSiteConfig(readFileSync(RUNTIME_TENANT.siteConfigPath, "utf8"));
+  } catch {
+    return null;
+  }
+})();
+export {
+  RUNTIME_PROJECT_ROOT,
+  RUNTIME_SITE_CONFIG,
+  RUNTIME_TENANT
+};

package/dist/tsconfigs/strict.json

@@ -0,0 +1,3 @@
+{
+  "extends": "astro/tsconfigs/strict"
+}

package/dist/types/agents.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/types/agents';

package/dist/types/agents.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/types/agents";

package/dist/types/cloudflare.d.ts

@@ -0,0 +1 @@
+export * from '@treeseed/sdk/types/cloudflare';

package/dist/types/cloudflare.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/types/cloudflare";

package/dist/types/forms.js

@@ -0,0 +1,4 @@
+const CONTACT_TYPES = ["question", "feedback", "collaboration", "issue"];
+export {
+  CONTACT_TYPES
+};

package/dist/utils/agents/adapters/execution.js

@@ -0,0 +1,90 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from "../cli-tools.js";
+import { getTreeseedAgentProviderSelections } from "../../../deploy/runtime.js";
+const execFileAsync = promisify(execFile);
+class StubExecutionAdapter {
+  async runTask(input) {
+    return {
+      status: "completed",
+      summary: `Stubbed Copilot execution for ${input.runId}.`,
+      stdout: [
+        "# Planned Task",
+        "",
+        "1. Inspect the requested architecture context.",
+        "2. Produce a safe local change artifact.",
+        "3. Summarize the implementation intent.",
+        "",
+        `Prompt digest: ${input.prompt.slice(0, 240)}`
+      ].join("\n"),
+      stderr: ""
+    };
+  }
+}
+class CopilotExecutionAdapter {
+  async runTask(input) {
+    const cli = normalizeAgentCliOptions(input.agent.cli);
+    const args = ["copilot", "-p", input.prompt];
+    if (cli.model) {
+      args.push("--model", cli.model);
+    }
+    args.push(...buildCopilotAllowToolArgs(cli.allowTools));
+    args.push(...cli.additionalArgs ?? []);
+    try {
+      const { stdout, stderr } = await execFileAsync("gh", args, {
+        cwd: process.cwd(),
+        env: process.env,
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return {
+        status: "completed",
+        summary: "Copilot task completed.",
+        stdout,
+        stderr
+      };
+    } catch (error) {
+      const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : error instanceof Error ? error.message : String(error);
+      return {
+        status: "failed",
+        summary: "Copilot task failed.",
+        stdout: "",
+        stderr
+      };
+    }
+  }
+}
+class ManualExecutionAdapter {
+  async runTask(input) {
+    return {
+      status: "completed",
+      summary: `Manual execution mode is enabled for ${input.runId}.`,
+      stdout: [
+        "# Manual Execution Required",
+        "",
+        "This agent run is configured for manual execution.",
+        "Review the prompt below and complete the work outside the automated adapter.",
+        "",
+        input.prompt
+      ].join("\n"),
+      stderr: ""
+    };
+  }
+}
+function createExecutionAdapter() {
+  const configuredMode = String(
+    process.env.TREESEED_AGENT_EXECUTION_PROVIDER ?? getTreeseedAgentProviderSelections().execution
+  ).toLowerCase();
+  if (configuredMode === "manual") {
+    return new ManualExecutionAdapter();
+  }
+  if (configuredMode !== "copilot") {
+    return new StubExecutionAdapter();
+  }
+  return new CopilotExecutionAdapter();
+}
+export {
+  CopilotExecutionAdapter,
+  ManualExecutionAdapter,
+  StubExecutionAdapter,
+  createExecutionAdapter
+};

package/dist/utils/agents/adapters/mutations.js

@@ -0,0 +1,30 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { GitRuntime } from "@treeseed/sdk/git-runtime";
+class LocalBranchMutationAdapter {
+  git;
+  constructor(repoRoot) {
+    this.git = new GitRuntime(
+      repoRoot,
+      process.env.TREESEED_AGENT_DISABLE_GIT === "true"
+    );
+  }
+  async writeArtifact(input) {
+    const branchName = `${input.agent.execution.branchPrefix}/${input.runId}`;
+    const worktreePath = await this.git.ensureWorktree(branchName);
+    const filePath = path.join(worktreePath, input.relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, input.content, "utf8");
+    const git = await this.git.commitFileChange(filePath, branchName, input.commitMessage);
+    return {
+      branchName: git.branchName,
+      commitMessage: git.commitMessage,
+      worktreePath: git.worktreePath,
+      commitSha: git.commitSha,
+      changedPaths: git.changedPaths
+    };
+  }
+}
+export {
+  LocalBranchMutationAdapter
+};

package/dist/utils/agents/adapters/notification.js

@@ -0,0 +1,16 @@
+class StubNotificationAdapter {
+  async deliver(input) {
+    return {
+      status: input.recipients.length ? "completed" : "waiting",
+      summary: input.recipients.length ? `Prepared ${input.recipients.length} notification(s).` : "No recipients available for notification.",
+      deliveredCount: input.recipients.length
+    };
+  }
+}
+function createNotificationAdapter() {
+  return new StubNotificationAdapter();
+}
+export {
+  StubNotificationAdapter,
+  createNotificationAdapter
+};

package/dist/utils/agents/adapters/repository.js

@@ -0,0 +1,61 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getTreeseedAgentProviderSelections } from "../../../deploy/runtime.js";
+const execFileAsync = promisify(execFile);
+class StubRepositoryInspectionAdapter {
+  async inspectBranch(input) {
+    return {
+      branchName: input.branchName,
+      changedPaths: [],
+      commitSha: null,
+      summary: input.branchName ? `Stub repository inspection for ${input.branchName}.` : "No branch to inspect."
+    };
+  }
+}
+class GitRepositoryInspectionAdapter {
+  async inspectBranch(input) {
+    if (!input.branchName) {
+      return {
+        branchName: null,
+        changedPaths: [],
+        commitSha: null,
+        summary: "No branch to inspect."
+      };
+    }
+    try {
+      const { stdout: changedStdout } = await execFileAsync(
+        "git",
+        ["diff", "--name-only", "HEAD~1..HEAD"],
+        { cwd: input.repoRoot, env: process.env }
+      );
+      const { stdout: shaStdout } = await execFileAsync("git", ["rev-parse", "HEAD"], {
+        cwd: input.repoRoot,
+        env: process.env
+      });
+      const changedPaths = changedStdout.split("\n").map((entry) => entry.trim()).filter(Boolean);
+      return {
+        branchName: input.branchName,
+        changedPaths,
+        commitSha: shaStdout.trim() || null,
+        summary: `Inspected ${changedPaths.length} changed path(s) on ${input.branchName}.`
+      };
+    } catch {
+      return {
+        branchName: input.branchName,
+        changedPaths: [],
+        commitSha: null,
+        summary: `Unable to inspect branch ${input.branchName}.`
+      };
+    }
+  }
+}
+function createRepositoryInspectionAdapter() {
+  return String(
+    process.env.TREESEED_AGENT_REPOSITORY_PROVIDER ?? getTreeseedAgentProviderSelections().repository
+  ).toLowerCase() !== "git" ? new StubRepositoryInspectionAdapter() : new GitRepositoryInspectionAdapter();
+}
+export {
+  GitRepositoryInspectionAdapter,
+  StubRepositoryInspectionAdapter,
+  createRepositoryInspectionAdapter
+};

package/dist/utils/agents/adapters/research.js

@@ -0,0 +1,25 @@
+class StubResearchAdapter {
+  async research(input) {
+    return {
+      status: "completed",
+      summary: `Research prepared for ${input.questionId}.`,
+      markdown: [
+        "# Research Summary",
+        "",
+        `Question: ${input.questionId}`,
+        `Reason: ${input.reason ?? "not provided"}`,
+        `Run: ${input.runId}`,
+        "",
+        "This is a stub research summary produced by the runtime adapter."
+      ].join("\n"),
+      sources: []
+    };
+  }
+}
+function createResearchAdapter() {
+  return new StubResearchAdapter();
+}
+export {
+  StubResearchAdapter,
+  createResearchAdapter
+};

package/dist/utils/agents/adapters/verification.js

@@ -0,0 +1,62 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getTreeseedAgentProviderSelections } from "../../../deploy/runtime.js";
+const execFileAsync = promisify(execFile);
+class StubVerificationAdapter {
+  async runChecks(input) {
+    return {
+      status: "completed",
+      summary: input.commands.length ? `Stub verification completed for ${input.runId}.` : "No verification commands configured.",
+      stdout: input.commands.join("\n"),
+      stderr: ""
+    };
+  }
+}
+class LocalVerificationAdapter {
+  async runChecks(input) {
+    if (!input.commands.length) {
+      return {
+        status: "waiting",
+        summary: "No verification commands configured.",
+        stdout: "",
+        stderr: ""
+      };
+    }
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    for (const command of input.commands) {
+      try {
+        const { stdout, stderr } = await execFileAsync("/bin/bash", ["-lc", command], {
+          env: process.env,
+          maxBuffer: 10 * 1024 * 1024
+        });
+        stdoutChunks.push(stdout);
+        stderrChunks.push(stderr);
+      } catch (error) {
+        return {
+          status: "failed",
+          summary: `Verification command failed: ${command}`,
+          stdout: stdoutChunks.join("\n"),
+          stderr: error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : String(error),
+          errorCategory: "execution_error"
+        };
+      }
+    }
+    return {
+      status: "completed",
+      summary: `Verification completed for ${input.commands.length} command(s).`,
+      stdout: stdoutChunks.join("\n"),
+      stderr: stderrChunks.join("\n")
+    };
+  }
+}
+function createVerificationAdapter() {
+  return String(
+    process.env.TREESEED_AGENT_VERIFICATION_PROVIDER ?? getTreeseedAgentProviderSelections().verification
+  ).toLowerCase() !== "local" ? new StubVerificationAdapter() : new LocalVerificationAdapter();
+}
+export {
+  LocalVerificationAdapter,
+  StubVerificationAdapter,
+  createVerificationAdapter
+};

package/dist/utils/agents/cli-tools.js

@@ -0,0 +1,5 @@
+import { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from "@treeseed/sdk/cli-tools";
+export {
+  buildCopilotAllowToolArgs,
+  normalizeAgentCliOptions
+};