@treeseed/sdk 0.11.0 → 0.12.4

package/dist/platform-operation-store.d.ts

@@ -1,4 +1,4 @@
-import { type PlatformOperation, type PlatformOperationEvent, type PlatformRunnerClaimRequest, type PlatformRunnerHeartbeatRequest, type PlatformRunnerJobUpdateRequest, type PlatformRunnerRegistrationRequest } from './platform-operations.ts';
+import { type PlatformOperation, type PlatformOperationEvent, type PlatformRunnerClaimRequest, type PlatformRunnerHeartbeatRequest, type PlatformRunnerJobUpdateRequest, type PlatformRunnerRegistrationRequest } from './platform-operations.js';
 export type DatabaseProvider = 'd1' | 'sqlite' | 'postgres';
 export interface RelationalDatabaseAdapter {
     readonly provider: DatabaseProvider;

package/dist/plugin-default.d.ts

@@ -22,7 +22,7 @@ declare const _default: {
         site: string[];
     };
     graphRankingProviders: {
-        default: import("./sdk-types.ts").SdkGraphRankingProvider;
+        default: import("./sdk-types.js").SdkGraphRankingProvider;
     };
 };
 export default _default;

package/dist/plugin-default.js

@@ -6,20 +6,35 @@ var plugin_default_default = defineTreeseedPlugin({
     forms: ["store_only", "notify_admin", "full_email"],
     operations: ["default"],
     agents: {
-      execution: ["stub", "manual", "copilot", "codex", "codex_subscription"],
+      execution: [
+        "copilot",
+        "codex",
+        "codex_subscription",
+        "jira",
+        "jira_issue_queue",
+        "human_issue_queue",
+        "github_issues",
+        "github_issue_queue",
+        "issue_queue",
+        "discord",
+        "discord_thread",
+        "workflow",
+        "workflow_operation",
+        "deterministic_workflow",
+        "github_actions",
+        "github_actions_workflow"
+      ],
       mutation: ["local_branch"],
-      repository: ["stub", "git"],
-      verification: ["stub", "local"],
-      notification: ["stub", "sdk_message"],
-      research: ["stub", "project_graph"],
+      repository: ["git"],
+      verification: ["local"],
+      notification: ["sdk_message"],
+      research: ["project_graph"],
       handlers: [
-        "planner",
-        "architect",
-        "engineer",
-        "notifier",
-        "researcher",
-        "reviewer",
-        "releaser"
+        "plan",
+        "research",
+        "act",
+        "review",
+        "report"
       ]
     },
     deploy: ["cloudflare"],

package/dist/project-import.d.ts

@@ -0,0 +1,91 @@
+import type { SeedProjectArchitecture, SeedProjectContentPublishTarget } from './seeds/types.js';
+export { githubRepositoryCredentialEnvName } from './operations/services/github-credentials.js';
+export type TreeseedRepositoryImportProvider = 'github';
+export type TreeseedRepositoryImportVisibility = 'public' | 'private';
+export interface TreeseedGitHubRepositoryObservation {
+    provider?: TreeseedRepositoryImportProvider | string;
+    owner?: string;
+    name?: string;
+    repository?: string;
+    defaultBranch?: string;
+    visibility?: TreeseedRepositoryImportVisibility | string;
+    htmlUrl?: string;
+    cloneUrl?: string;
+    files?: string[];
+    directories?: string[];
+    manifests?: Record<string, unknown>;
+}
+export interface TreeseedRepositoryImportInput {
+    team: string;
+    repository: string;
+    observation?: TreeseedGitHubRepositoryObservation;
+    rootPath?: string;
+    sitePath?: string;
+    contentPath?: string | null;
+    visibility?: TreeseedRepositoryImportVisibility | string;
+    credentialRef?: string;
+    contentPublishTarget?: SeedProjectContentPublishTarget;
+    env?: Record<string, string | undefined>;
+}
+export interface TreeseedRepositoryImportDiagnostic {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+    path?: string;
+}
+export interface TreeseedRepositoryImportPathCandidates {
+    rootPath: string[];
+    sitePath: string[];
+    contentPath: string[];
+    manifests: string[];
+}
+export interface TreeseedRepositoryImportPlan {
+    ok: boolean;
+    provider: TreeseedRepositoryImportProvider;
+    team: string;
+    repository: {
+        owner: string;
+        name: string;
+        slug: string;
+        defaultBranch: string;
+        visibility: TreeseedRepositoryImportVisibility;
+        htmlUrl: string;
+        cloneUrl: string;
+    };
+    credentialRef: string;
+    credential: {
+        ref: string;
+        configured: boolean;
+        source: 'repository' | 'fallback' | 'missing' | 'explicit';
+        repositoryScopedRef: string;
+    };
+    architecture: SeedProjectArchitecture;
+    candidates: TreeseedRepositoryImportPathCandidates;
+    diagnostics: TreeseedRepositoryImportDiagnostic[];
+    plannedRecords: {
+        project: {
+            slug: string;
+            name: string;
+            visibility: TreeseedRepositoryImportVisibility;
+        };
+        hubRepository: {
+            role: 'software';
+            provider: 'github';
+            owner: string;
+            name: string;
+            url: string;
+            defaultBranch: string;
+            credentialRef: string;
+        };
+        contentSource: {
+            contentRuntimeSource: SeedProjectArchitecture['contentRuntimeSource'];
+            contentPath: string | null;
+            contentPublishTarget: SeedProjectContentPublishTarget | null;
+        };
+        treeDxLibrary: {
+            libraryId: string;
+            contentPath: string | null;
+        };
+    };
+}
+export declare function planTreeseedRepositoryImport(input: TreeseedRepositoryImportInput): TreeseedRepositoryImportPlan;

package/dist/project-import.js

@@ -0,0 +1,257 @@
+import { TREESEED_GITHUB_TOKEN_ENV } from "./service-credentials.js";
+import {
+  githubRepositoryCredentialEnvName,
+  resolveGitHubCredentialForRepository
+} from "./operations/services/github-credentials.js";
+import { githubRepositoryCredentialEnvName as githubRepositoryCredentialEnvName2 } from "./operations/services/github-credentials.js";
+const SITE_PATH_CANDIDATES = [".", "docs", "site", "apps/web"];
+const CONTENT_PATH_CANDIDATES = ["src/content", "docs/src/content", "docs", "content"];
+const KNOWN_MANIFESTS = ["treeseed.site.yaml", "treeseed.package.yaml", "src/manifest.yaml"];
+function trim(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function normalizeRepoSlug(repository) {
+  const raw = String(repository ?? "").trim().replace(/^https?:\/\/github\.com\//iu, "").replace(/^git@github\.com:/iu, "").replace(/^ssh:\/\/git@github\.com\//iu, "").replace(/\.git$/iu, "").replace(/^\/+|\/+$/gu, "");
+  const [owner, name, ...extra] = raw.split("/").filter(Boolean);
+  if (!owner || !name || extra.length > 0) {
+    throw new Error(`Invalid GitHub repository "${repository}". Expected owner/name.`);
+  }
+  return { owner, name, slug: `${owner}/${name}` };
+}
+function slugifyProject(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "") || "project";
+}
+function titleFromRepositoryName(name) {
+  return name.split(/[-_\s]+/gu).filter(Boolean).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join(" ") || name;
+}
+function normalizePathList(values) {
+  if (!Array.isArray(values)) return [];
+  return unique(values.map((entry) => trim(entry).replace(/^\/+|\/+$/gu, "") || "."));
+}
+function pathExists(path, files, directories) {
+  if (path === ".") return true;
+  return files.has(path) || directories.has(path) || [...files].some((entry) => entry.startsWith(`${path}/`));
+}
+function hasFile(path, files) {
+  return files.has(path);
+}
+function hasAnyFileUnder(path, files, pattern) {
+  const prefix = path === "." ? "" : `${path}/`;
+  return [...files].some((entry) => entry.startsWith(prefix) && pattern.test(entry.slice(prefix.length)));
+}
+function assertNoSecretMaterial(value, path = "input") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const forbiddenKeys = /* @__PURE__ */ new Set([
+    "plaintext",
+    "plainText",
+    "value",
+    "raw",
+    "rawSecret",
+    "secretValue",
+    "unencrypted",
+    "token",
+    "accessToken",
+    "privateKey",
+    "sshPrivateKey",
+    "passphrase",
+    "password",
+    "derivedKey",
+    "decrypted",
+    "decryptedPayload",
+    "decryptedSecret",
+    "credentialValue"
+  ]);
+  for (const [key, nested] of Object.entries(value)) {
+    if (key === "env") continue;
+    if (forbiddenKeys.has(key)) {
+      throw new Error(`Repository import ${path} cannot include plaintext credentials, tokens, or secret material.`);
+    }
+    if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+      assertNoSecretMaterial(nested, `${path}.${key}`);
+    }
+  }
+}
+function selectSitePath(files, directories, override, diagnostics) {
+  if (override) return override;
+  const candidates = SITE_PATH_CANDIDATES.filter((candidate) => {
+    if (candidate === ".") {
+      return hasFile("treeseed.site.yaml", files) || hasFile("package.json", files) || hasAnyFileUnder("src/pages", files, /.+/u) || hasAnyFileUnder("src/routes", files, /.+/u) || hasFile("astro.config.ts", files) || hasFile("astro.config.ts", files);
+    }
+    return pathExists(candidate, files, directories) && (hasFile(`${candidate}/treeseed.site.yaml`, files) || hasFile(`${candidate}/package.json`, files) || hasFile(`${candidate}/astro.config.ts`, files) || hasFile(`${candidate}/astro.config.ts`, files) || hasAnyFileUnder(`${candidate}/src/pages`, files, /.+/u) || hasAnyFileUnder(candidate, files, /\.(md|mdx)$/iu));
+  });
+  if (candidates.includes("docs")) return "docs";
+  if (candidates.length > 0) return candidates[0];
+  diagnostics.push({
+    severity: "warning",
+    code: "site_path_assumed_root",
+    message: 'No obvious site path was observed; import will use sitePath "." without restructuring the repository.'
+  });
+  return ".";
+}
+function selectContentPath(files, directories, override, sitePath, diagnostics) {
+  if (override) return override;
+  const candidates = CONTENT_PATH_CANDIDATES.filter((candidate) => {
+    if (!pathExists(candidate, files, directories)) return false;
+    if (candidate.endsWith("src/content")) return true;
+    return hasAnyFileUnder(candidate, files, /\.(md|mdx|json|ya?ml)$/iu);
+  });
+  if (sitePath === "docs" && candidates.includes("docs/src/content")) return "docs/src/content";
+  if (candidates.includes("src/content")) return "src/content";
+  if (sitePath === "docs" && candidates.includes("docs")) return "docs";
+  if (candidates.length > 0) return candidates[0];
+  diagnostics.push({
+    severity: "info",
+    code: "content_path_not_observed",
+    message: "No local content path was observed; hosted runtime can use TreeDX/R2 content sources until content is materialized."
+  });
+  return "";
+}
+function discoverCandidates(files, directories) {
+  return {
+    rootPath: ["."],
+    sitePath: SITE_PATH_CANDIDATES.filter((candidate) => pathExists(candidate, files, directories)),
+    contentPath: CONTENT_PATH_CANDIDATES.filter((candidate) => pathExists(candidate, files, directories)),
+    manifests: KNOWN_MANIFESTS.filter((manifest) => hasFile(manifest, files))
+  };
+}
+function normalizeCredentialRef(input, repositorySlug) {
+  const explicit = trim(input.credentialRef);
+  const repositoryScopedEnvName = githubRepositoryCredentialEnvName(repositorySlug);
+  if (explicit) {
+    if (!explicit.startsWith("env:TREESEED_GITHUB_TOKEN")) {
+      throw new Error("Repository import credentialRef must be an env:TREESEED_GITHUB_TOKEN reference.");
+    }
+    return {
+      credentialRef: explicit,
+      credential: {
+        ref: explicit,
+        configured: Boolean(input.env?.[explicit.slice(4)]),
+        source: "explicit",
+        repositoryScopedRef: `env:${repositoryScopedEnvName}`
+      }
+    };
+  }
+  const resolution = resolveGitHubCredentialForRepository(repositorySlug, { env: input.env ?? process.env });
+  const envName = resolution.source === "repository" ? resolution.envName : TREESEED_GITHUB_TOKEN_ENV;
+  return {
+    credentialRef: `env:${envName}`,
+    credential: {
+      ref: `env:${envName}`,
+      configured: resolution.configured,
+      source: resolution.source,
+      repositoryScopedRef: `env:${repositoryScopedEnvName}`
+    }
+  };
+}
+function planTreeseedRepositoryImport(input) {
+  assertNoSecretMaterial({
+    ...input,
+    env: void 0
+  });
+  assertNoSecretMaterial(input.observation ?? {}, "observation");
+  const team = trim(input.team);
+  if (!team) throw new Error("Repository import requires a team slug or id.");
+  const repo = normalizeRepoSlug(input.repository);
+  const observation = input.observation ?? {};
+  const observedRepo = normalizeRepoSlug(trim(observation.repository) || `${trim(observation.owner) || repo.owner}/${trim(observation.name) || repo.name}`);
+  const owner = observedRepo.owner;
+  const name = observedRepo.name;
+  const repositorySlug = `${owner}/${name}`;
+  const files = new Set(normalizePathList(observation.files));
+  const directories = new Set(normalizePathList(observation.directories));
+  for (const manifest of Object.keys(observation.manifests ?? {})) {
+    files.add(manifest);
+  }
+  const diagnostics = [];
+  if (observation.provider && observation.provider !== "github") {
+    throw new Error(`Unsupported repository import provider "${observation.provider}". GitHub is the only v1 import provider.`);
+  }
+  const candidates = discoverCandidates(files, directories);
+  if (candidates.sitePath.length > 1) {
+    diagnostics.push({
+      severity: "warning",
+      code: "ambiguous_site_path",
+      message: `Multiple site path candidates were observed: ${candidates.sitePath.join(", ")}. Override with --site-path if needed.`
+    });
+  }
+  const rootPath = trim(input.rootPath) || ".";
+  const sitePath = selectSitePath(files, directories, trim(input.sitePath), diagnostics);
+  const contentPath = selectContentPath(files, directories, trim(input.contentPath), sitePath, diagnostics);
+  const contentPublishTarget = input.contentPublishTarget ?? {
+    kind: "cloudflare_r2",
+    manifestPath: `teams/${slugifyProject(team)}/projects/${slugifyProject(name)}/published/common.json`
+  };
+  const architecture = {
+    topology: "single_repository_site",
+    rootPath,
+    sitePath,
+    ...contentPath ? { contentPath } : {},
+    contentRuntimeSource: "r2_published_manifest",
+    localContentMaterialization: contentPath ? "existing_path" : "none",
+    contentPublishTarget,
+    requiresLocalContentForCi: false,
+    requiresLocalContentForDeploy: false
+  };
+  const credential = normalizeCredentialRef(input, repositorySlug);
+  if (!credential.credential.configured) {
+    diagnostics.push({
+      severity: "warning",
+      code: "github_credential_missing",
+      message: `No configured GitHub token was observed for ${credential.credential.repositoryScopedRef} or env:${TREESEED_GITHUB_TOKEN_ENV}. The import plan is safe, but execute may require credentials.`
+    });
+  }
+  const visibility = trim(input.visibility || observation.visibility) === "private" ? "private" : "public";
+  const htmlUrl = trim(observation.htmlUrl) || `https://github.com/${repositorySlug}`;
+  const cloneUrl = trim(observation.cloneUrl) || `${htmlUrl}.git`;
+  return {
+    ok: true,
+    provider: "github",
+    team,
+    repository: {
+      owner,
+      name,
+      slug: repositorySlug,
+      defaultBranch: trim(observation.defaultBranch) || "main",
+      visibility,
+      htmlUrl,
+      cloneUrl
+    },
+    credentialRef: credential.credentialRef,
+    credential: credential.credential,
+    architecture,
+    candidates,
+    diagnostics,
+    plannedRecords: {
+      project: {
+        slug: slugifyProject(name),
+        name: titleFromRepositoryName(name),
+        visibility
+      },
+      hubRepository: {
+        role: "software",
+        provider: "github",
+        owner,
+        name,
+        url: htmlUrl,
+        defaultBranch: trim(observation.defaultBranch) || "main",
+        credentialRef: credential.credentialRef
+      },
+      contentSource: {
+        contentRuntimeSource: architecture.contentRuntimeSource,
+        contentPath: architecture.contentPath ?? null,
+        contentPublishTarget
+      },
+      treeDxLibrary: {
+        libraryId: `${slugifyProject(team)}/${slugifyProject(name)}`,
+        contentPath: architecture.contentPath ?? null
+      }
+    }
+  };
+}
+export {
+  githubRepositoryCredentialEnvName2 as githubRepositoryCredentialEnvName,
+  planTreeseedRepositoryImport
+};

package/dist/project-workflow.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectConnection, ProjectLaunchHostBindingInput, RemoteJobStatus } from './sdk-types.ts';
+import type { ProjectConnection, ProjectLaunchHostBindingInput, RemoteJobStatus } from './sdk-types.js';
 export declare const PROJECT_TEAM_CAPABILITIES: readonly ["launch_projects", "edit_direct", "manage_workstreams", "stage_releases", "publish_releases", "publish_market_listings", "manage_products", "manage_billing", "approve_remote_execution"];
 export declare const PROJECT_JOB_STATUSES: readonly ["queued", "running", "waiting_for_approval", "failed", "completed", "rolled_back", "cancelled"];
 export declare const WORKSTREAM_STATES: readonly ["drafting", "active_local", "verifying", "saved_remote", "in_staging", "archived"];

package/dist/reconcile/bootstrap-systems.d.ts

@@ -1,5 +1,5 @@
-import type { TreeseedDeployConfig } from '../platform/contracts.ts';
-import type { TreeseedDesiredUnit } from './contracts.ts';
+import type { TreeseedDeployConfig } from '../platform/contracts.js';
+import type { TreeseedDesiredUnit } from './contracts.js';
 export declare const TREESEED_BOOTSTRAP_SYSTEMS: readonly ["github", "data", "web", "api", "agents"];
 export type TreeseedBootstrapSystem = typeof TREESEED_BOOTSTRAP_SYSTEMS[number] | 'all';
 export type TreeseedRunnableBootstrapSystem = Exclude<TreeseedBootstrapSystem, 'all'>;

package/dist/reconcile/bootstrap-systems.js

@@ -64,13 +64,13 @@ function hasValue(env, key) {
 function missingForSystem(system, env) {
   switch (system) {
     case "github":
-      return hasValue(env, "GH_TOKEN") || hasValue(env, "GITHUB_TOKEN") ? [] : ["GH_TOKEN"];
+      return hasValue(env, "TREESEED_GITHUB_TOKEN") ? [] : ["TREESEED_GITHUB_TOKEN"];
     case "data":
     case "web":
-      return hasValue(env, "CLOUDFLARE_API_TOKEN") ? [] : ["CLOUDFLARE_API_TOKEN"];
+      return hasValue(env, "TREESEED_CLOUDFLARE_API_TOKEN") ? [] : ["TREESEED_CLOUDFLARE_API_TOKEN"];
     case "api":
     case "agents":
-      return hasValue(env, "RAILWAY_API_TOKEN") ? [] : ["RAILWAY_API_TOKEN"];
+      return hasValue(env, "TREESEED_RAILWAY_API_TOKEN") ? [] : ["TREESEED_RAILWAY_API_TOKEN"];
     default:
       return [];
   }

package/dist/reconcile/builtin-adapters.d.ts

@@ -1,3 +1,9 @@
-import type { TreeseedReconcileAdapter } from './contracts.ts';
+import type { TreeseedReconcileAdapter } from './contracts.js';
 export declare function createCloudflareReconcileAdapters(): TreeseedReconcileAdapter[];
 export declare function createRailwayReconcileAdapters(): TreeseedReconcileAdapter[];
+export declare function createPackageReconcileAdapters(): TreeseedReconcileAdapter[];
+export declare function createGitHubReconcileAdapters(): TreeseedReconcileAdapter[];
+export declare function createDockerReconcileAdapters(): TreeseedReconcileAdapter[];
+export declare function createLocalProcessReconcileAdapters(): TreeseedReconcileAdapter[];
+export declare function createCapacityProviderReconcileAdapters(): TreeseedReconcileAdapter[];
+export declare function createReleaseGateReconcileAdapters(): TreeseedReconcileAdapter[];