@treeseed/sdk 0.3.1 → 0.3.3

package/dist/platform/plugins/runtime.js

@@ -18,8 +18,28 @@ function isPathLikePluginReference(packageName) {
 }
 function resolveLocalDefaultPluginPath() {
   const candidates = [
-    path.resolve(runtimeDir, "../../../../core/dist/plugin-default.js")
+    path.resolve(runtimeDir, "../../../../core/dist/plugin-default.js"),
+    path.resolve(runtimeDir, "../../../../dist/plugin-default.js")
   ];
+  let current = runtimeDir;
+  while (true) {
+    const packageJsonPath = path.resolve(current, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = require2(packageJsonPath);
+        if (packageJson?.name === "@treeseed/core") {
+          candidates.push(path.resolve(current, "dist/plugin-default.js"));
+          break;
+        }
+      } catch {
+      }
+    }
+    const parent = path.resolve(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
   for (const candidate of candidates) {
     if (existsSync(candidate)) {
       return candidate;

package/dist/scripts/test-smoke.js

@@ -124,6 +124,8 @@ try {
         type: 'module',
         scripts: {
             'verify:direct': 'node --input-type=module -e "console.log(\'treeseed-sdk-smoke-verify\')"',
+            'verify:local': 'node --input-type=module -e "process.env.TREESEED_VERIFY_DRIVER=\'direct\'; console.log(\'treeseed-sdk-smoke-verify-local\')"',
+            'verify:action': 'node --input-type=module -e "process.env.TREESEED_VERIFY_DRIVER=\'act\'; console.log(\'treeseed-sdk-smoke-verify-action\')"',
         },
     }, null, 2)}\n`, 'utf8');
     run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk/verification");'], installRoot);

package/dist/sdk-types.d.ts

@@ -569,7 +569,7 @@ export interface SdkGraphRefreshPayload {
 }
 export interface SdkCreateMessageRequest {
     type: string;
-    payload: Record<string, unknown>;
+    payload: Record<string, unknown> | string;
     relatedModel?: string | null;
     relatedId?: string | null;
     priority?: number;

package/dist/utils/agents/contracts/messages.js

@@ -40,7 +40,8 @@ function ensureNumber(value, label) {
   return value;
 }
 function parseAgentMessagePayload(type, payloadJson) {
-  const parsed = JSON.parse(payloadJson);
+  const decoded = JSON.parse(payloadJson);
+  const parsed = typeof decoded === "string" ? JSON.parse(decoded) : decoded;
   switch (type) {
     case "question_priority_updated":
       return {

package/dist/verification.d.ts

@@ -4,6 +4,11 @@ export type TreeseedVerifyDriverOptions = {
     driver?: TreeseedVerifyDriver;
     eventName?: string;
     write?: (message: string, stream?: 'stdout' | 'stderr') => void;
+    runCommand?: (command: string, args: string[], cwd: string) => number;
+    checkCommand?: (command: string, args: string[], cwd: string) => {
+        ok: boolean;
+        detail: string;
+    };
 };
 export type TreeseedVerifyDriverStatus = {
     packageRoot: string;
@@ -15,6 +20,11 @@ export type TreeseedVerifyDriverStatus = {
     ghActAvailable: boolean;
     dockerAvailable: boolean;
     canUseAct: boolean;
+    workspaceRoot: string | null;
+    currentPackageName: string | null;
+    localTreeseedPackageNames: string[];
+    localTreeseedSiblingDependencies: string[];
+    prefersDirectForLocalWorkspace: boolean;
 };
 export declare function getTreeseedVerifyDriverStatus(options?: TreeseedVerifyDriverOptions): TreeseedVerifyDriverStatus;
 export declare function runTreeseedVerifyDriver(options?: TreeseedVerifyDriverOptions): number;

package/dist/verification.js

@@ -1,5 +1,5 @@
-import { existsSync } from "node:fs";
-import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import * as childProcess from "node:child_process";
 import { basename, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 function defaultWrite(message, stream = "stdout") {
@@ -8,7 +8,7 @@ function defaultWrite(message, stream = "stdout") {
 `);
 }
 function run(command, args, cwd) {
-  const result = spawnSync(command, args, {
+  const result = childProcess.spawnSync(command, args, {
     cwd,
     env: process.env,
     stdio: "inherit"
@@ -16,7 +16,7 @@ function run(command, args, cwd) {
   return result.status ?? 1;
 }
 function check(command, args, cwd) {
-  const result = spawnSync(command, args, {
+  const result = childProcess.spawnSync(command, args, {
     cwd,
     env: process.env,
     stdio: "pipe",
@@ -28,6 +28,76 @@ function check(command, args, cwd) {
 ${result.stdout ?? ""}`.trim()
   };
 }
+function readPackageManifest(packageJsonPath) {
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function findWorkspaceRoot(packageRoot) {
+  let current = packageRoot;
+  while (true) {
+    const packagesRoot = resolve(current, "packages");
+    if (existsSync(packagesRoot)) {
+      const packageDirs = readdirSync(packagesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => resolve(packagesRoot, entry.name)).filter((dirPath) => existsSync(resolve(dirPath, "package.json")));
+      if (packageDirs.length > 0) {
+        return {
+          workspaceRoot: current,
+          packageDirs
+        };
+      }
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveLocalWorkspaceContext(packageRoot) {
+  const currentManifest = readPackageManifest(resolve(packageRoot, "package.json"));
+  const currentPackageName = typeof currentManifest?.name === "string" ? currentManifest.name : null;
+  const workspace = findWorkspaceRoot(packageRoot);
+  if (!workspace) {
+    return {
+      workspaceRoot: null,
+      currentPackageName,
+      localTreeseedPackageNames: [],
+      localTreeseedSiblingDependencies: []
+    };
+  }
+  const localPackages = workspace.packageDirs.map((dirPath) => ({
+    dirPath,
+    manifest: readPackageManifest(resolve(dirPath, "package.json"))
+  })).filter((entry) => Boolean(entry.manifest?.name));
+  const currentPackage = localPackages.find((entry) => entry.dirPath === packageRoot);
+  if (!currentPackage) {
+    return {
+      workspaceRoot: null,
+      currentPackageName,
+      localTreeseedPackageNames: [],
+      localTreeseedSiblingDependencies: []
+    };
+  }
+  const localTreeseedPackageNames = localPackages.map((entry) => entry.manifest.name).filter((name) => name.startsWith("@treeseed/")).sort();
+  const localTreeseedPackageSet = new Set(localTreeseedPackageNames);
+  const declaredDependencies = {
+    ...currentPackage.manifest.dependencies ?? {},
+    ...currentPackage.manifest.devDependencies ?? {},
+    ...currentPackage.manifest.peerDependencies ?? {}
+  };
+  const localTreeseedSiblingDependencies = Object.keys(declaredDependencies).filter((name) => name.startsWith("@treeseed/")).filter((name) => localTreeseedPackageSet.has(name)).sort();
+  return {
+    workspaceRoot: workspace.workspaceRoot,
+    currentPackageName: currentPackage.manifest.name ?? currentPackageName,
+    localTreeseedPackageNames,
+    localTreeseedSiblingDependencies
+  };
+}
 function getTreeseedVerifyDriverStatus(options = {}) {
   const packageRoot = resolve(options.packageRoot ?? process.cwd());
   const workflowPath = resolve(packageRoot, ".github", "workflows", "verify.yml");
@@ -35,8 +105,11 @@ function getTreeseedVerifyDriverStatus(options = {}) {
   const eventName = options.eventName ?? process.env.TREESEED_VERIFY_EVENT ?? "workflow_dispatch";
   const inGitHubActions = process.env.GITHUB_ACTIONS === "true";
   const workflowPresent = existsSync(workflowPath);
-  const ghAct = check("gh", ["act", "--version"], packageRoot);
-  const docker = check("docker", ["info"], packageRoot);
+  const workspace = resolveLocalWorkspaceContext(packageRoot);
+  const checkCommand = options.checkCommand ?? check;
+  const ghAct = checkCommand("gh", ["act", "--version"], packageRoot);
+  const docker = checkCommand("docker", ["info"], packageRoot);
+  const prefersDirectForLocalWorkspace = !inGitHubActions && driver === "auto" && workspace.localTreeseedSiblingDependencies.length > 0;
   return {
     packageRoot,
     workflowPath,
@@ -46,14 +119,21 @@ function getTreeseedVerifyDriverStatus(options = {}) {
     workflowPresent,
     ghActAvailable: ghAct.ok,
     dockerAvailable: docker.ok,
-    canUseAct: workflowPresent && ghAct.ok && docker.ok
+    canUseAct: workflowPresent && ghAct.ok && docker.ok,
+    workspaceRoot: workspace.workspaceRoot,
+    currentPackageName: workspace.currentPackageName,
+    localTreeseedPackageNames: workspace.localTreeseedPackageNames,
+    localTreeseedSiblingDependencies: workspace.localTreeseedSiblingDependencies,
+    prefersDirectForLocalWorkspace
   };
 }
 function runTreeseedVerifyDriver(options = {}) {
   const write = options.write ?? defaultWrite;
   const status = getTreeseedVerifyDriverStatus(options);
+  const runCommand = options.runCommand ?? run;
+  const checkCommand = options.checkCommand ?? check;
   if (status.driver === "direct" || status.inGitHubActions) {
-    return run("npm", ["run", "verify:direct"], status.packageRoot);
+    return runCommand("npm", ["run", "verify:direct"], status.packageRoot);
   }
   if (status.driver === "act") {
     if (!status.workflowPresent) {
@@ -61,19 +141,22 @@ function runTreeseedVerifyDriver(options = {}) {
       return 1;
     }
     if (!status.ghActAvailable) {
-      const detail = check("gh", ["act", "--version"], status.packageRoot).detail;
+      const detail = checkCommand("gh", ["act", "--version"], status.packageRoot).detail;
       write(detail || "Treeseed verify requires `gh act` when TREESEED_VERIFY_DRIVER=act.", "stderr");
       return 1;
     }
     if (!status.dockerAvailable) {
-      const detail = check("docker", ["info"], status.packageRoot).detail;
+      const detail = checkCommand("docker", ["info"], status.packageRoot).detail;
       write(detail || "Treeseed verify requires a running Docker daemon when TREESEED_VERIFY_DRIVER=act.", "stderr");
       return 1;
     }
-    return run("gh", ["act", status.eventName, "-W", ".github/workflows/verify.yml", "-j", "verify"], status.packageRoot);
+    return runCommand("gh", ["act", status.eventName, "-W", ".github/workflows/verify.yml", "-j", "verify"], status.packageRoot);
+  }
+  if (status.prefersDirectForLocalWorkspace) {
+    return runCommand("npm", ["run", "verify:direct"], status.packageRoot);
   }
   if (status.canUseAct) {
-    return run("gh", ["act", status.eventName, "-W", ".github/workflows/verify.yml", "-j", "verify"], status.packageRoot);
+    return runCommand("gh", ["act", status.eventName, "-W", ".github/workflows/verify.yml", "-j", "verify"], status.packageRoot);
   }
   if (!status.workflowPresent) {
     write("Treeseed verify warning: package-local verify workflow is missing; falling back to verify:direct.", "stderr");
@@ -82,7 +165,7 @@ function runTreeseedVerifyDriver(options = {}) {
   } else if (!status.dockerAvailable) {
     write("Treeseed verify warning: Docker is unavailable; falling back to verify:direct.", "stderr");
   }
-  return run("npm", ["run", "verify:direct"], status.packageRoot);
+  return runCommand("npm", ["run", "verify:direct"], status.packageRoot);
 }
 const invokedPath = process.argv[1] ? resolve(process.argv[1]) : "";
 const invokedBasename = basename(invokedPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -41,6 +41,8 @@
     "fixtures:check": "node ./scripts/run-ts.mjs ./scripts/fixture-tools.ts check",
     "lint": "npm run fixtures:check && npm run build:dist",
     "verify:direct": "npm run release:verify",
+    "verify:local": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='direct'; await import('@treeseed/sdk/scripts/verify-driver')\"",
+    "verify:action": "node --input-type=module -e \"process.env.TREESEED_VERIFY_DRIVER='act'; await import('@treeseed/sdk/scripts/verify-driver')\"",
     "verify": "node ./scripts/verify-driver.mjs",
     "release:setup": "npm run setup:ci",
     "release:check-tag": "node ./scripts/run-ts.mjs ./scripts/assert-release-tag-version.ts",