@toothfairyai/tfcode 2.5.8 → 2.5.10

package/package.json

@@ -1,169 +1,33 @@
 {
-  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.5.8",
   "name": "@toothfairyai/tfcode",
-  "type": "module",
-  "license": "MIT",
-  "files": [
-    "bin",
-    "app",
-    "postinstall.mjs",
-    "LICENSE"
-  ],
-  "scripts": {
-    "prepare": "effect-language-service patch || true",
-    "postinstall": "node scripts/postinstall.cjs",
-    "typecheck": "tsgo --noEmit",
-    "test": "bun test --timeout 30000",
-    "build": "bun run script/build-tfcode.ts",
-    "build:single": "bun run script/build-tfcode.ts --single",
-    "publish:upload": "bun run script/publish-tfcode.ts --upload",
-    "publish:npm": "bun run script/publish-tfcode.ts --npm",
-    "publish:brew": "bun run script/publish-tfcode.ts --brew",
-    "publish:all": "bun run script/publish-tfcode.ts --all",
-    "dev": "bun run --conditions=browser ./src/index.ts",
-    "db": "bun drizzle-kit"
-  },
+  "version": "2.5.10",
   "bin": {
-    "tfcode": "./bin/tfcode"
+    "tfcode": "./bin/tfcode.js"
   },
-  "exports": {
-    "./*": "./src/*.ts"
-  },
-  "imports": {
-    "#db": {
-      "bun": "./src/storage/db.bun.ts",
-      "node": "./src/storage/db.node.ts",
-      "default": "./src/storage/db.bun.ts"
-    }
+  "scripts": {
+    "postinstall": "node ./postinstall.mjs"
   },
-  "devDependencies": {
-    "@babel/core": "7.28.4",
-    "@effect/language-service": "0.79.0",
-    "@octokit/webhooks-types": "7.6.1",
-    "@opencode-ai/script": "workspace:*",
-    "@parcel/watcher-darwin-arm64": "2.5.1",
-    "@parcel/watcher-darwin-x64": "2.5.1",
-    "@parcel/watcher-linux-arm64-glibc": "2.5.1",
-    "@parcel/watcher-linux-arm64-musl": "2.5.1",
-    "@parcel/watcher-linux-x64-glibc": "2.5.1",
-    "@parcel/watcher-linux-x64-musl": "2.5.1",
-    "@parcel/watcher-win32-arm64": "2.5.1",
-    "@parcel/watcher-win32-x64": "2.5.1",
-    "@standard-schema/spec": "1.0.0",
-    "@tsconfig/bun": "catalog:",
-    "@types/babel__core": "7.20.5",
-    "@types/bun": "1.3.11",
-    "@types/cross-spawn": "6.0.6",
-    "@types/mime-types": "3.0.1",
-    "@types/node": "22.13.9",
-    "@types/semver": "^7.5.8",
-    "@types/turndown": "5.0.5",
-    "@types/which": "3.0.4",
-    "@types/ws": "8.18.1",
-    "@types/yargs": "17.0.33",
-    "@typescript/native-preview": "catalog:",
-    "drizzle-kit": "catalog:",
-    "drizzle-orm": "catalog:",
-    "typescript": "catalog:",
-    "vscode-languageserver-types": "3.17.5",
-    "why-is-node-running": "3.2.2",
-    "zod-to-json-schema": "3.24.5"
+  "license": "MIT",
+  "optionalDependencies": {
+    "@toothfairyai/tfcode-linux-arm64": "2.5.10",
+    "@toothfairyai/tfcode-windows-x64": "2.5.10",
+    "@toothfairyai/tfcode-linux-x64-baseline-musl": "2.5.10",
+    "@toothfairyai/tfcode-darwin-x64-baseline": "2.5.10",
+    "@toothfairyai/tfcode-linux-x64-musl": "2.5.10",
+    "@toothfairyai/tfcode-windows-x64-baseline": "2.5.10",
+    "@toothfairyai/tfcode-linux-arm64-musl": "2.5.10",
+    "@toothfairyai/tfcode-windows-arm64": "2.5.10",
+    "@toothfairyai/tfcode-linux-x64": "2.5.10",
+    "@toothfairyai/tfcode-darwin-x64": "2.5.10",
+    "@toothfairyai/tfcode-linux-x64-baseline": "2.5.10",
+    "@toothfairyai/tfcode-darwin-arm64": "2.5.10"
   },
-  "dependencies": {
-    "@actions/core": "1.11.1",
-    "@actions/github": "6.0.1",
-    "@agentclientprotocol/sdk": "0.14.1",
-    "@ai-sdk/amazon-bedrock": "3.0.82",
-    "@ai-sdk/anthropic": "2.0.65",
-    "@ai-sdk/azure": "2.0.91",
-    "@ai-sdk/cerebras": "1.0.36",
-    "@ai-sdk/cohere": "2.0.22",
-    "@ai-sdk/deepinfra": "1.0.36",
-    "@ai-sdk/gateway": "2.0.30",
-    "@ai-sdk/google": "2.0.54",
-    "@ai-sdk/google-vertex": "3.0.106",
-    "@ai-sdk/groq": "2.0.34",
-    "@ai-sdk/mistral": "2.0.27",
-    "@ai-sdk/openai": "2.0.89",
-    "@ai-sdk/openai-compatible": "1.0.32",
-    "@ai-sdk/perplexity": "2.0.23",
-    "@ai-sdk/provider": "2.0.1",
-    "@ai-sdk/provider-utils": "3.0.21",
-    "@ai-sdk/togetherai": "1.0.34",
-    "@ai-sdk/vercel": "1.0.33",
-    "@ai-sdk/xai": "2.0.51",
-    "@aws-sdk/credential-providers": "3.993.0",
-    "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "catalog:",
-    "@hono/standard-validator": "0.1.5",
-    "@hono/zod-validator": "catalog:",
-    "@modelcontextprotocol/sdk": "1.29.0",
-    "@octokit/graphql": "9.0.2",
-    "@octokit/rest": "catalog:",
-    "@openauthjs/openauth": "catalog:",
-    "@opencode-ai/gateway": "workspace:*",
-    "@opencode-ai/plugin": "workspace:*",
-    "@opencode-ai/script": "workspace:*",
-    "@opencode-ai/sdk": "workspace:*",
-    "@opencode-ai/util": "workspace:*",
-    "@openrouter/ai-sdk-provider": "1.5.4",
-    "@opentui/core": "0.2.16",
-    "@opentui/solid": "0.2.16",
-    "@parcel/watcher": "2.5.1",
-    "@pierre/diffs": "catalog:",
-    "@solid-primitives/event-bus": "1.1.2",
-    "@solid-primitives/scheduled": "1.5.2",
-    "@standard-schema/spec": "1.0.0",
-    "@zip.js/zip.js": "2.7.62",
-    "ai": "catalog:",
-    "ai-gateway-provider": "2.3.1",
-    "bonjour-service": "1.3.0",
-    "bun-pty": "0.4.8",
-    "chokidar": "4.0.3",
-    "clipboardy": "4.0.0",
-    "croner": "10.0.1",
-    "cross-spawn": "^7.0.6",
-    "decimal.js": "10.5.0",
-    "diff": "catalog:",
-    "drizzle-orm": "catalog:",
-    "effect": "catalog:",
-    "fuzzysort": "3.1.0",
-    "gitlab-ai-provider": "5.2.2",
-    "glob": "13.0.5",
-    "google-auth-library": "10.5.0",
-    "gray-matter": "4.0.3",
-    "hono": "catalog:",
-    "hono-openapi": "catalog:",
-    "ignore": "7.0.5",
-    "jsonc-parser": "3.3.1",
-    "marked": "catalog:",
-    "mime-types": "3.0.2",
-    "minimatch": "10.0.3",
-    "open": "10.1.2",
-    "opencode-gitlab-auth": "2.0.0",
-    "opentui-spinner": "0.0.6",
-    "partial-json": "0.1.7",
-    "react": "19.2.4",
-    "react-dom": "19.2.4",
-    "remeda": "catalog:",
-    "semver": "^7.6.3",
-    "solid-js": "catalog:",
-    "strip-ansi": "7.1.2",
-    "tree-sitter-bash": "0.25.0",
-    "tree-sitter-powershell": "0.25.10",
-    "turndown": "7.2.0",
-    "ulid": "catalog:",
-    "vscode-jsonrpc": "8.2.1",
-    "web-tree-sitter": "0.25.10",
-    "which": "6.0.1",
-    "ws": "8.21.0",
-    "xdg-basedir": "5.1.0",
-    "yargs": "18.0.0",
-    "zod": "catalog:",
-    "zod-to-json-schema": "3.24.5"
+  "engines": {
+    "node": ">=18"
   },
-  "overrides": {
-    "drizzle-orm": "catalog:"
+  "homepage": "https://toothfairyai.com/developers/tfcode",
+  "repository": {
+    "type": "git",
+    "url": "https://gitea.toothfairyai.com/ToothFairyAI/tf_code.git"
   }
-}
+}

package/postinstall.mjs

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { spawnSync } from "child_process"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const GITEA_HOST = process.env.TFCODE_GITEA_HOST || "gitea.toothfairyai.com"
+const GITEA_REPO = process.env.TFCODE_GITEA_REPO || "ToothFairyAI/tf_code"
+
+function detectPlatform() {
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "windows"
+      break
+    default:
+      platform = os.platform()
+  }
+
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    default:
+      arch = os.arch()
+  }
+
+  // Check for AVX2 on x64
+  let needsBaseline = false
+  if (arch === "x64" && (platform === "linux" || platform === "darwin")) {
+    try {
+      if (platform === "linux") {
+        const cpuinfo = fs.readFileSync("/proc/cpuinfo", "utf8")
+        needsBaseline = !cpuinfo.toLowerCase().includes("avx2")
+      } else if (platform === "darwin") {
+        const result = spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], { encoding: "utf8" })
+        needsBaseline = result.stdout.trim() !== "1"
+      }
+    } catch {}
+  }
+
+  // Check for musl on Linux
+  let abi = ""
+  if (platform === "linux") {
+    try {
+      if (fs.existsSync("/etc/alpine-release")) {
+        abi = "musl"
+      } else {
+        const result = spawnSync("ldd", ["--version"], { encoding: "utf8" })
+        if ((result.stdout + result.stderr).toLowerCase().includes("musl")) {
+          abi = "musl"
+        }
+      }
+    } catch {}
+  }
+
+  return { platform, arch, needsBaseline, abi }
+}
+
+async function getVersion() {
+  try {
+    const res = await fetch(`https://${GITEA_HOST}/api/v1/repos/${GITEA_REPO}/releases/latest`)
+    const data = await res.json()
+    return data.tag_name?.replace(/^v/, "") || "1.0.0"
+  } catch {
+    return "1.0.0"
+  }
+}
+
+// Detect the machine architecture of an existing binary. Returns "arm64",
+// "x64", or null when it can't be determined (null => keep existing binary).
+function detectBinaryMachineArch(binaryPath, platform) {
+  try {
+    if (platform === "win32") {
+      const buf = fs.readFileSync(binaryPath)
+      if (buf.length < 0x40) return null
+      const pe = buf.readUInt32LE(0x3c)
+      if (pe + 6 > buf.length) return null
+      const machine = buf.readUInt16LE(pe + 4)
+      if (machine === 0x8664) return "x64"
+      if (machine === 0xaa64) return "arm64"
+      return null
+    }
+    const out = spawnSync("file", [binaryPath], { encoding: "utf8" }).stdout || ""
+    if (/arm64|aarch64/i.test(out)) return "arm64"
+    if (/x86-64|x86_64/i.test(out)) return "x64"
+    return null
+  } catch {
+    return null
+  }
+}
+
+// A missing/unparseable binary is treated as a match so installs never break
+// when detection isn't possible; a real mismatch forces a re-download.
+function binaryArchMatches(binaryPath, expectedArch, platform) {
+  const actual = detectBinaryMachineArch(binaryPath, platform)
+  if (!actual) return true
+  return actual === expectedArch
+}
+
+async function downloadBinary() {
+  const { platform, arch, needsBaseline, abi } = detectPlatform()
+  const version = await getVersion()
+
+  // Check if binary already exists (included in npm package)
+  const binaryName = platform === "windows" ? "tfcode.exe" : "tfcode"
+  const binDir = path.join(__dirname, "bin")
+  const existingBinary = path.join(binDir, binaryName)
+
+  if (fs.existsSync(existingBinary) && binaryArchMatches(existingBinary, arch, platform)) {
+    console.log(`✓ Binary already exists at ${existingBinary}`)
+    // Still need to copy app dir from platform package if missing
+    const targetAppDir = path.join(binDir, "app")
+    if (!fs.existsSync(path.join(targetAppDir, "dist", "index.html"))) {
+      let target = `tfcode-${platform}-${arch}`
+      if (needsBaseline) target += "-baseline"
+      if (abi) target += `-${abi}`
+      const pkgName = `@toothfairyai/${target}`
+      try {
+        const pkgUrl = import.meta.resolve(`${pkgName}/package.json`)
+        const pkgDir = path.dirname(fileURLToPath(pkgUrl))
+        const srcAppDir = path.join(pkgDir, "bin", "app")
+        if (fs.existsSync(path.join(srcAppDir, "dist", "index.html"))) {
+          fs.cpSync(srcAppDir, targetAppDir, { recursive: true })
+          console.log("✓ Web app copied from platform package")
+        }
+        copyComputerAssets(path.join(pkgDir, "bin"), binDir)
+      } catch (e) {
+        console.log(`! Could not copy web app: ${e.message}`)
+      }
+    }
+    return
+  }
+
+  // Build filename for download
+  let target = `tfcode-${platform}-${arch}`
+  if (needsBaseline) target += "-baseline"
+  if (abi) target += `-${abi}`
+
+  const ext = platform === "linux" ? ".tar.gz" : ".zip"
+  const filename = `${target}${ext}`
+  const url = `https://${GITEA_HOST}/${GITEA_REPO}/releases/download/v${version}/${filename}`
+
+  console.log(`Downloading tfcode v${version} for ${target}...`)
+
+  // Download
+  if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true })
+
+  const tmpDir = path.join(os.tmpdir(), `tfcode-install-${process.pid}`)
+  fs.mkdirSync(tmpDir, { recursive: true })
+  const archivePath = path.join(tmpDir, filename)
+
+  // Use curl to download
+  const curlResult = spawnSync("curl", ["-fsSL", "-o", archivePath, url], { stdio: "inherit" })
+  if (curlResult.status !== 0) {
+    console.error(`Failed to download from ${url}`)
+    console.error("Trying npm package fallback...")
+
+    // Fallback to npm optionalDependencies
+    try {
+      const pkgName = `@toothfairyai/${target}`
+
+      // ESM-compatible module resolution
+      let pkgDir
+      try {
+        const pkgUrl = import.meta.resolve(`${pkgName}/package.json`)
+        const pkgPath = fileURLToPath(pkgUrl)
+        pkgDir = path.dirname(pkgPath)
+      } catch (e) {
+        console.error(`Could not resolve ${pkgName}:`, e.message)
+        throw e
+      }
+
+      const binaryName = platform === "windows" ? "tfcode.exe" : "tfcode"
+      const binaryPath = path.join(pkgDir, "bin", binaryName)
+
+      console.log(`Looking for binary at: ${binaryPath}`)
+
+      if (fs.existsSync(binaryPath)) {
+        console.log(`Found binary at npm package location`)
+        setupBinary(binaryPath, platform)
+        return
+      } else {
+        console.error(`Binary not found at ${binaryPath}`)
+      }
+    } catch (e) {
+      console.error("npm package fallback failed:", e.message)
+    }
+
+    console.error("")
+    console.error("Installation failed. The binary could not be downloaded or found.")
+    console.error("")
+    console.error("Possible solutions:")
+    console.error("  1. If this is a private installation, set TFCODE_GITEA_HOST to an accessible host")
+    console.error("  2. Manually download the binary and place it in the bin/ directory")
+    console.error("  3. Contact ToothFairyAI support for assistance")
+    console.error("")
+    process.exit(1)
+  }
+
+  // Extract
+  console.log("Extracting...")
+  if (platform === "linux") {
+    spawnSync("tar", ["-xzf", archivePath, "-C", tmpDir], { stdio: "inherit" })
+  } else {
+    spawnSync("unzip", ["-q", archivePath, "-d", tmpDir], { stdio: "inherit" })
+  }
+
+  // Move binary
+  const extractedBinary = path.join(tmpDir, "tfcode")
+  const targetBinary = path.join(binDir, binaryName)
+
+  if (fs.existsSync(extractedBinary)) {
+    if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
+    fs.copyFileSync(extractedBinary, targetBinary)
+    fs.chmodSync(targetBinary, 0o755)
+    console.log(`Installed tfcode to ${targetBinary}`)
+  }
+
+  // Move app directory
+  const extractedAppDir = path.join(tmpDir, "app")
+  const targetAppDir = path.join(binDir, "app")
+  if (fs.existsSync(path.join(extractedAppDir, "dist", "index.html"))) {
+    if (fs.existsSync(targetAppDir)) fs.rmSync(targetAppDir, { recursive: true, force: true })
+    fs.cpSync(extractedAppDir, targetAppDir, { recursive: true })
+    console.log("Installed web app")
+  }
+
+  // Move bundled computer-use helpers (cliclick on macOS, if archived)
+  copyComputerAssets(tmpDir, binDir)
+
+  // Cleanup
+  fs.rmSync(tmpDir, { recursive: true, force: true })
+}
+
+// Copy bundled computer-use helper binaries (e.g. cliclick on macOS) from a
+// source bin dir into the installed bin dir, so `tfcode computer setup` finds
+// them next to the binary without Homebrew/apt. No-op when absent. npm may
+// strip the exec bit, so chmod the helpers back to 0755.
+function copyComputerAssets(srcBinDir, dstBinDir) {
+  const srcComputer = path.join(srcBinDir, "computer")
+  if (!fs.existsSync(srcComputer)) return
+  const dstComputer = path.join(dstBinDir, "computer")
+  if (fs.existsSync(dstComputer)) fs.rmSync(dstComputer, { recursive: true, force: true })
+  fs.cpSync(srcComputer, dstComputer, { recursive: true })
+  for (const name of fs.readdirSync(dstComputer)) {
+    try {
+      fs.chmodSync(path.join(dstComputer, name), 0o755)
+    } catch {}
+  }
+  console.log("✓ Computer-use helpers copied from platform package")
+}
+
+function setupBinary(sourcePath, platform) {
+  const binDir = path.join(__dirname, "bin")
+  const binaryName = platform === "windows" ? "tfcode.exe" : "tfcode"
+  const targetBinary = path.join(binDir, binaryName)
+
+  if (!fs.existsSync(binDir)) fs.mkdirSync(binDir, { recursive: true })
+  if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
+
+  // Try hardlink, fall back to copy
+  try {
+    fs.linkSync(sourcePath, targetBinary)
+  } catch {
+    fs.copyFileSync(sourcePath, targetBinary)
+  }
+
+  fs.chmodSync(targetBinary, 0o755)
+  console.log(`tfcode installed to ${targetBinary}`)
+
+  // Also copy app dir from platform package
+  const sourceDir = path.dirname(sourcePath)
+  const srcAppDir = path.join(sourceDir, "app")
+  const targetAppDir = path.join(binDir, "app")
+  if (fs.existsSync(path.join(srcAppDir, "dist", "index.html"))) {
+    if (fs.existsSync(targetAppDir)) fs.rmSync(targetAppDir, { recursive: true, force: true })
+    fs.cpSync(srcAppDir, targetAppDir, { recursive: true })
+    console.log("Web app copied from platform package")
+  }
+  // Also copy bundled computer-use helpers (cliclick on macOS) if present.
+  copyComputerAssets(sourceDir, binDir)
+}
+
+async function main() {
+  console.log("")
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+  console.log("  tfcode - ToothFairyAI's official coding agent")
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+  console.log("")
+
+  // Download and setup binary
+  await downloadBinary()
+
+  // Check for Python (needed for TF integration)
+  try {
+    const result = spawnSync("python3", ["--version"], { encoding: "utf8" })
+    if (result.status === 0) {
+      console.log(`✓ Found ${result.stdout.trim()}`)
+
+      // Install Python SDK
+      console.log("Installing ToothFairyAI Python SDK...")
+      const pipResult = spawnSync(
+        "python3",
+        ["-m", "pip", "install", "--user", "--break-system-packages", "toothfairyai", "pydantic", "httpx", "rich"],
+        {
+          stdio: "inherit",
+        },
+      )
+
+      if (pipResult.status === 0) {
+        console.log("✓ Python SDK installed")
+      } else {
+        console.log("! Python SDK install failed, run manually:")
+        console.log("  pip install toothfairyai pydantic httpx rich")
+      }
+    }
+  } catch {
+    console.log("! Python 3.10+ not found. Install with:")
+    console.log("  macOS:  brew install python@3.12")
+    console.log("  Ubuntu: sudo apt install python3.12")
+    console.log("  Windows: Download from python.org/downloads")
+    console.log("")
+  }
+
+  console.log("")
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+  console.log("✓ tfcode installed successfully!")
+  console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+  console.log("")
+  console.log("Quick Start:")
+  console.log("")
+  console.log("  1. Set credentials:")
+  console.log('     export TF_WORKSPACE_ID="your-workspace-id"')
+  console.log('     export TF_API_KEY="your-api-key"')
+  console.log("")
+  console.log("  2. Validate:")
+  console.log("     tfcode validate")
+  console.log("")
+  console.log("  3. Sync tools:")
+  console.log("     tfcode sync")
+  console.log("")
+  console.log("  4. Start coding:")
+  console.log("     tfcode")
+  console.log("")
+  // Optional feature — keep it short and clearly labeled so the coding-first
+  // Quick Start isn't noised up. Point npm installers at the one-command setup.
+  const cuPlatform = os.platform()
+  const cuHint =
+    cuPlatform === "darwin"
+      ? "a permissions dialog will appear (Accessibility & Screen Recording); cliclick is bundled."
+      : cuPlatform === "win32"
+        ? "no extra installs needed — pre-compiles the input helper."
+        : "installs xdotool + a screenshot tool via your package manager."
+  console.log("  Computer use (optional — control the OS GUI: mouse, keyboard, screen):")
+  console.log("     tfcode computer setup    " + cuHint)
+  console.log("     tfcode computer doctor    verify it works")
+  console.log("")
+  console.log("Documentation: https://toothfairyai.com/developers/tfcode")
+  console.log("")
+}
+
+main().catch(console.error)

package/python/tf_sync/__init__.py

@@ -0,0 +1,21 @@
+"""
+tf-sync: ToothFairyAI workspace sync layer for tfcode
+"""
+
+from tf_sync.agents import sync_agents
+from tf_sync.mcp import sync_mcp_servers
+from tf_sync.tools import sync_tools, ToolType
+from tf_sync.config import TFConfig, load_config, validate_credentials, get_region_urls
+
+__all__ = [
+    "sync_agents",
+    "sync_mcp_servers", 
+    "sync_tools",
+    "ToolType",
+    "TFConfig",
+    "load_config",
+    "validate_credentials",
+    "get_region_urls",
+]
+
+__version__ = "0.1.0"

package/python/tf_sync/agents.py

@@ -0,0 +1,39 @@
+"""
+Agent sync module for tfcode.
+
+NOTE: This module is reserved for future implementation.
+Currently, tfcode only syncs tools (MCP, Skills, Database, Functions).
+Agent sync will be added in a later phase.
+"""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from tf_sync.config import TFConfig
+
+
+class AgentSyncResult(BaseModel):
+    """Result of agent sync operation."""
+    
+    success: bool
+    agents: list[dict[str, Any]] = []
+    error: str | None = None
+
+
+def sync_agents(config: TFConfig) -> AgentSyncResult:
+    """
+    Sync agents from ToothFairyAI workspace.
+    
+    NOTE: Currently not implemented. Reserved for future use.
+    
+    Args:
+        config: TFConfig instance
+    
+    Returns:
+        AgentSyncResult (currently always returns not implemented)
+    """
+    return AgentSyncResult(
+        success=False,
+        error="Agent sync not yet implemented. Use tools sync for now.",
+    )