orkestrate 0.1.14 → 0.2.0

package/packs/extension-builder/harnesses/opencode/skills/orkestrate-pack-author/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: orkestrate-pack-author
+description: >
+  Author Orkestrate packs — pack.yaml, harnesses/opencode native config, skills,
+  plugins, validate and install. Use when creating or editing agent packs for
+  Orkestrate, scaffolding pack layout, or preparing GitHub/registry publish.
+  For launching runs use orkestrate skill instead.
+compatibility: opencode
+metadata:
+  platform: orkestrate
+---
+
+# Orkestrate pack author
+
+## Pack layout
+
+```text
+my-pack/
+  pack.yaml
+  harnesses/
+    opencode/
+      opencode.json
+      agents/<agent>.md
+      skills/<skill-name>/SKILL.md
+      plugins/
+  scaffold/
+```
+
+## pack.yaml (required fields)
+
+- `id` — lowercase slug (matches folder name)
+- `name`, `description`, `harness` (e.g. `opencode`)
+- `version` optional
+
+## Harness slice (A)
+
+All OpenCode behavior lives in **`harnesses/opencode/`**:
+
+- `opencode.json` — permissions, agents, MCP, plugins
+- `agents/*.md` — agent prompts (frontmatter + body)
+- `skills/*/SKILL.md` — OpenCode skills with YAML frontmatter (`name`, `description`)
+
+No Orkestrate tool DSL — native OpenCode config only.
+
+## Workflow
+
+1. Create directory under workspace or copy a seed pack
+2. Edit `pack.yaml` and `harnesses/opencode/*`
+3. `orkestrate pack validate <id>`
+4. `orkestrate pack install <id>` if needed locally
+5. `orkestrate run launch <id>` to test (new terminal)
+
+## Orchestrator packs
+
+Include skills `orkestrate` and `orkestrate-pack-author` in `permission.skill` in `opencode.json`.
+
+## Publish
+
+Push to public GitHub; registry stores index + `source_url` + ref + `pack_path` (later phase).

package/packs/extension-builder/pack.yaml

@@ -0,0 +1,5 @@
+id: extension-builder
+name: extension-builder
+description: Build Orkestrate packs, drivers, and platform extensions.
+version: "0.1.0"
+harness: opencode

package/src/cli/cmd/extension-submit.ts

@@ -0,0 +1,267 @@
+import { validateManifest, createManifestTemplate, type ExtensionManifest, type ExtensionType } from "../../sdk/extensions/manifest";
+
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const BLUE = "\x1b[34m";
+
+const REGISTRY_URL = process.env.ORKESTRATE_REGISTRY_URL || "https://orkestrate.space/api/registry";
+
+export async function runExtensionSubmit(options: {
+  path?: string;
+  type?: ExtensionType;
+  init?: boolean;
+  outputPath?: string;
+}): Promise<void> {
+  const { path, type, init, outputPath } = options;
+
+  if (init) {
+    if (!type) {
+      console.error(`${RED}Error:${RESET} --type required with --init`);
+      console.error(`Types: adapter, profile-pack, skill-pack, mcp-pack, command-pack`);
+      process.exitCode = 1;
+      return;
+    }
+    
+    await initManifest(type, outputPath ?? "orkestrate.extension.json");
+    return;
+  }
+
+  if (!path) {
+    console.error(`${RED}Error:${RESET} Usage: orkestrate extension submit <path-to-manifest> [--init --type <type>]`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`${BOLD}Validating extension manifest...${RESET}`);
+  console.log("");
+
+  // Load manifest
+  let manifest: ExtensionManifest;
+  try {
+    const file = Bun.file(path);
+    if (!await file.exists()) {
+      console.error(`${RED}Error:${RESET} Manifest file not found: ${path}`);
+      process.exitCode = 1;
+      return;
+    }
+    manifest = await file.json();
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Failed to load manifest:`, error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Validate
+  const { valid, errors } = validateManifest(manifest);
+  if (!valid) {
+    console.error(`${RED}Validation failed:${RESET}`);
+    for (const err of errors) {
+      console.error(`  ${RED}✗${RESET} ${err}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`${GREEN}✓${RESET} Manifest validation passed`);
+  console.log("");
+
+  // Show summary
+  console.log(`${BOLD}Extension:${RESET} ${manifest.name} (${manifest.id})`);
+  console.log(`${BOLD}Version:${RESET} ${manifest.version}`);
+  console.log(`${BOLD}Type:${RESET} ${manifest.type}`);
+  console.log(`${BOLD}Entry:${RESET} ${manifest.entry}`);
+  if (manifest.harness) console.log(`${BOLD}Harness:${RESET} ${manifest.harness}`);
+  if (manifest.profiles?.length) console.log(`${BOLD}Profiles:${RESET} ${manifest.profiles.join(", ")}`);
+  if (manifest.skills?.length) console.log(`${BOLD}Skills:${RESET} ${manifest.skills.join(", ")}`);
+  console.log("");
+
+  // Get auth token
+  const token = await getAuthToken();
+  if (!token) {
+    console.log(`${YELLOW}Authentication required${RESET}`);
+    const proceed = await confirm("Continue with GitHub authentication?");
+    if (!proceed) {
+      console.log("Cancelled.");
+      return;
+    }
+    const authResult = await startAuthFlow();
+    if (!authResult) {
+      console.error(`${RED}Error:${RESET} Authentication failed`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  // Submit
+  console.log(`${BLUE}Submitting extension to registry...${RESET}`);
+  try {
+    const response = await fetch(`${REGISTRY_URL}/extensions/submit`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+      },
+      body: JSON.stringify({
+        manifest,
+        source: "cli",
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: "Unknown error" }));
+      throw new Error(`Registry error: ${response.status} - ${error.message ?? "Unknown"}`);
+    }
+
+    const result = await response.json();
+    console.log(`${GREEN}✓${RESET} Extension submitted successfully!`);
+    console.log("");
+    console.log(`Submission ID: ${result.submission_id}`);
+    console.log(`Status: ${result.status}`);
+    if (result.review_url) console.log(`Review URL: ${result.review_url}`);
+
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Submission failed:`, error instanceof Error ? error.message : String(error));
+    console.log("");
+    console.log("Manual submission:");
+    console.log(`  1. Go to ${BLUE}https://orkestrate.space/submit${RESET}`);
+    console.log("  2. Sign in with GitHub");
+    console.log("  3. Select 'Extension' and upload manifest");
+    process.exitCode = 1;
+  }
+}
+
+async function initManifest(type: ExtensionType, outputPath: string): Promise<void> {
+  const template = createManifestTemplate(type);
+  
+  // Check if file exists
+  const file = Bun.file(outputPath);
+  if (await file.exists()) {
+    const overwrite = await confirm(`${YELLOW}File exists: ${outputPath}. Overwrite?${RESET}`);
+    if (!overwrite) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+
+  await Bun.write(outputPath, JSON.stringify(template, null, 2) + "\n");
+  console.log(`${GREEN}✓${RESET} Created manifest template: ${outputPath}`);
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  1. Edit ${outputPath} with your extension details`);
+  console.log(`  2. Run ${BOLD}orkestrate extension validate ${outputPath}${RESET} to verify`);
+  console.log(`  3. Run ${BOLD}orkestrate extension submit ${outputPath}${RESET} to publish`);
+}
+
+async function getAuthToken(): Promise<string | null> {
+  const authPath = `${process.env.HOME || process.env.USERPROFILE}/.orkestrate/auth.json`;
+  try {
+    const file = Bun.file(authPath);
+    if (await file.exists()) {
+      const auth = await file.json();
+      if (auth.access_token && auth.expires_at && Date.now() < auth.expires_at) {
+        return auth.access_token;
+      }
+    }
+  } catch {}
+  
+  if (process.env.ORKESTRATE_AUTH_TOKEN) {
+    return process.env.ORKESTRATE_AUTH_TOKEN;
+  }
+  
+  return null;
+}
+
+async function startAuthFlow(): Promise<string | null> {
+  console.log(`${BLUE}Opening browser for GitHub authentication...${RESET}`);
+  
+  const authUrl = `${REGISTRY_URL}/auth/device`;
+  try {
+    const response = await fetch(authUrl, { method: "POST" });
+    const data = await response.json();
+    
+    if (data.device_code && data.verification_uri_complete) {
+      const { spawn } = await import("node:child_process");
+      const url = data.verification_uri_complete;
+      
+      let opened = false;
+      if (process.platform === "darwin") {
+        spawn("open", [url]);
+        opened = true;
+      } else if (process.platform === "win32") {
+        spawn("cmd", ["/c", "start", url]);
+        opened = true;
+      } else if (process.platform === "linux") {
+        spawn("xdg-open", [url]);
+        opened = true;
+      }
+      
+      if (!opened) {
+        console.log(`Please open: ${BLUE}${url}${RESET}`);
+      }
+      
+      console.log(`Or visit: ${BLUE}${data.verification_uri}${RESET} and enter code: ${BOLD}${data.user_code}${RESET}`);
+      console.log("Waiting for authentication...");
+      
+      return await pollForToken(data.device_code, data.interval ?? 5);
+    }
+  } catch (error) {
+    console.error("Auth flow error:", error);
+  }
+  
+  return null;
+}
+
+async function pollForToken(deviceCode: string, interval: number): Promise<string | null> {
+  const maxAttempts = 180 / interval;
+  
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await new Promise(r => setTimeout(r, interval * 1000));
+    
+    try {
+      const response = await fetch(`${REGISTRY_URL}/auth/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: deviceCode, grant_type: "urn:ietf:params:oauth:grant-type:device_code" }),
+      });
+      
+      if (response.ok) {
+        const data = await response.json();
+        if (data.access_token) {
+          const authPath = `${process.env.HOME || process.env.USERPROFILE}/.orkestrate/auth.json`;
+          await Bun.write(authPath, JSON.stringify({
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            expires_at: Date.now() + (data.expires_in * 1000),
+          }, null, 2));
+          
+          console.log(`${GREEN}✓${RESET} Authentication successful!`);
+          return data.access_token;
+        }
+      } else if (response.status === 400) {
+        const error = await response.json().catch(() => ({}));
+        if (error.error === "authorization_pending") continue;
+        if (error.error === "slow_down") { interval += 5; continue; }
+        if (error.error === "expired_token") { console.log("Expired."); return null; }
+        if (error.error === "access_denied") { console.log("Denied."); return null; }
+      }
+    } catch (error) {
+      console.error("Polling error:", error);
+    }
+  }
+  
+  console.log("Authentication timed out.");
+  return null;
+}
+
+function confirm(message: string): Promise<boolean> {
+  return new Promise(resolve => {
+    console.log(`${message} (y/N): `);
+    process.stdin.once("data", data => {
+      const input = data.toString().trim().toLowerCase();
+      resolve(input === "y" || input === "yes");
+    });
+  });
+}

package/src/cli/cmd/pack-create.ts

@@ -0,0 +1,43 @@
+import { createPackFromTemplate } from "../../sdk/packs/create";
+import { validatePackLayout } from "../../sdk/packs/store";
+import { toPack, parsePackManifest } from "../../sdk/packs/schema";
+import { findPackManifestInDir, parseManifestYaml } from "../../sdk/packs/fs";
+import { PACK_MANIFEST } from "../../sdk/packs/paths";
+
+export async function runPackCreate(
+  id: string,
+  options: { template?: string; description?: string; global?: boolean }
+): Promise<void> {
+  const dest = await createPackFromTemplate({
+    id,
+    template: options.template,
+    description: options.description,
+    target: options.global ? "global" : "workspace",
+  });
+
+  const manifestPath = await findPackManifestInDir(dest);
+  if (!manifestPath) {
+    throw new Error(`Created pack is missing ${PACK_MANIFEST}`);
+  }
+  const raw = await Bun.file(manifestPath).text();
+  const manifest = parsePackManifest(parseManifestYaml(raw));
+  const pack = toPack(manifest, dest, manifestPath);
+  const { errors, warnings } = await validatePackLayout(pack);
+
+  console.log(`Created pack at:\n  ${dest}\n`);
+  if (warnings.length) {
+    console.log("Warnings:");
+    for (const w of warnings) console.log(`  ⚠ ${w}`);
+  }
+  if (errors.length) {
+    console.log("Fix these before launch:");
+    for (const e of errors) console.log(`  ✗ ${e}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log("Next:");
+  console.log(`  orkestrate pack validate ${id}`);
+  console.log(`  orkestrate run launch ${id}`);
+  console.log(`  bun run dev   # TUI → select ${id} → Enter`);
+}

package/src/cli/cmd/pack.ts

@@ -0,0 +1,53 @@
+import { installCatalogPack, listBundledCatalog, listInstalledPacks } from "../../sdk/packs/catalog";
+import { resolvePack, validatePackLayout } from "../../sdk/packs/store";
+import { seedBundledToGlobalIfMissing } from "../../sdk/packs/store";
+
+export async function runPackList(): Promise<void> {
+  await seedBundledToGlobalIfMissing();
+  const installed = await listInstalledPacks();
+  console.log("Installed packs:\n");
+  for (const { pack, scope } of installed) {
+    console.log(`  ${pack.id}  (${scope})  harness=${pack.harness}`);
+    console.log(`    ${pack.description}`);
+  }
+  const bundled = await listBundledCatalog();
+  const notInstalled = bundled.filter((b) => !b.installed);
+  if (notInstalled.length > 0) {
+    console.log("\nBundled catalog (not installed):\n");
+    for (const entry of notInstalled) {
+      console.log(`  ${entry.slug}`);
+    }
+  }
+}
+
+export async function runPackInstall(slug: string, global = false): Promise<void> {
+  const pack = await installCatalogPack(slug, { target: global ? "global" : "workspace" });
+  console.log(`Installed pack: ${pack.id}`);
+  console.log(`  ${pack.packRoot}`);
+}
+
+export async function runPackValidate(packId: string): Promise<void> {
+  const pack = await resolvePack(packId);
+  const { errors, warnings } = await validatePackLayout(pack);
+  const adapter = (await import("../../sdk/registry")).getAdapter(pack.harness);
+  if (!adapter) {
+    errors.push(`No driver for harness "${pack.harness}"`);
+  } else {
+    const status = await adapter.detect();
+    if (!status.installed) {
+      errors.push(`Harness not installed: ${status.error ?? "unknown"}`);
+    }
+  }
+  if (warnings.length) {
+    console.log("Warnings:");
+    for (const w of warnings) console.log(`  ⚠ ${w}`);
+  }
+  if (errors.length) {
+    console.error("Validation failed:");
+    for (const e of errors) console.error(`  ✗ ${e}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`Pack "${pack.id}" is valid.`);
+  console.log(`  ${pack.packRoot}`);
+}

package/src/cli/cmd/profile-create.ts

@@ -0,0 +1,199 @@
+import { listProfiles, saveProfile, workspaceProfilesDir } from "../../sdk/profiles/load";
+import { parseProfile, type Profile } from "../../sdk/profiles/schema";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+const TEMPLATES: Record<string, Omit<Profile, "name">> = {
+  "extension-builder": {
+    description: "Specialized profile for building Orkestrate extensions and adapters",
+    harness: "opencode",
+    info: `I am a profile builder for the Orkestrate workbench. I help create new agent profiles, extensions, and harness adapters.
+
+## Capabilities
+- **Profile Authoring**: Design valid agent profiles with proper metadata and config
+- **Extension Development**: Write OrkExtension modules with activation hooks
+- **Adapter Creation**: Build HarnessAdapter implementations for new runtimes
+- **Validation**: Verify profiles/extensions compile and conform to interfaces
+
+## Key References
+- \`src/sdk/profiles/schema.ts\` - Profile schema and validation
+- \`src/sdk/extensions/types.ts\` - Extension interface
+- \`src/sdk/types.ts\` - HarnessAdapter interface
+- \`extensions/opencode-adapter/index.ts\` - Example adapter
+
+## Workflow
+1. Define profile purpose and target harness
+2. Write \`info\` intro (this field) + \`config\` (model, tools, resources)
+3. Run \`orkestrate profile validate <name>\` to verify
+4. Test launch via \`orkestrate\` TUI
+5. Submit to registry when ready`,
+    config: {
+      workspace: { root: ".", policy: "current-directory" },
+      model: { provider: "default", id: "default", thinking: "high", cycle: [] },
+      prompt: "Help create, validate, and package Orkestrate profiles and extensions.",
+      resources: { skills: ["orkestrate"], prompts: [], extensions: [], mcpServers: [] },
+      tools: { allow: ["read", "write", "edit", "bash", "grep", "glob"], deny: [] },
+      session: { dir: ".orkestrate/opencode-sessions/profile-builder" },
+    },
+  },
+  "coding": {
+    description: "General-purpose coding agent",
+    harness: "opencode",
+    info: `I am a general-purpose software development agent.
+
+## Capabilities
+- **Code Editing**: Read, write, edit files with full language support
+- **Shell Access**: Run commands, tests, builds, git operations
+- **Search & Navigate**: Grep, glob, LSP-powered code intelligence
+- **Task Management**: Todo tracking for complex multi-step work
+
+## Workflow
+1. Understand the task and repository context
+2. Make small, reviewable changes
+3. Verify with tests and typechecks
+4. Follow repository conventions
+
+## Constraints
+- Prefer minimal, focused changes
+- Ask before destructive operations
+- Respect existing code style`,
+    config: {
+      workspace: { root: ".", policy: "current-directory" },
+      model: { provider: "default", id: "default", thinking: "default", cycle: [] },
+      prompt: "Use the Orkestrate coding profile. Prioritize small, reviewable changes, clear verification, and repository instructions.",
+      resources: { skills: ["orkestrate"], prompts: [], extensions: [], mcpServers: [] },
+      tools: { allow: ["read", "grep", "glob", "bash", "edit", "write"], deny: [] },
+      session: { dir: ".orkestrate/opencode-sessions/coding" },
+    },
+  },
+  "research": {
+    description: "Research and analysis agent",
+    harness: "opencode",
+    info: `I am a research agent for deep analysis, literature review, and synthesis.
+
+## Capabilities
+- **Web Research**: Fetch and analyze online sources
+- **Document Analysis**: Read and summarize PDFs, papers, docs
+- **Synthesis**: Combine findings into structured reports
+- **Fact Checking**: Verify claims against sources
+
+## Workflow
+1. Define research question and scope
+2. Gather sources (web, local files, papers)
+3. Analyze and extract key findings
+4. Synthesize into structured output with citations
+
+## Tools
+- Web fetch/search for live data
+- File reading for local documents
+- Todo tracking for multi-phase research`,
+    config: {
+      workspace: { root: ".", policy: "current-directory" },
+      model: { provider: "default", id: "default", thinking: "high", cycle: [] },
+      prompt: "Conduct thorough research. Cite sources. Distinguish facts from speculation.",
+      resources: { skills: ["orkestrate"], prompts: [], extensions: [], mcpServers: [] },
+      tools: { allow: ["read", "write", "edit", "bash", "grep", "glob", "webfetch", "websearch"], deny: [] },
+      session: { dir: ".orkestrate/opencode-sessions/research" },
+    },
+  },
+};
+
+export async function runProfileCreate(options: {
+  name: string;
+  template?: string;
+  interactive?: boolean;
+  global?: boolean;
+}): Promise<void> {
+  const { name, template, interactive, global } = options;
+
+  // Validate name
+  if (!/^[a-z0-9][a-z0-9-_]*$/.test(name)) {
+    console.error(`${RED}Error:${RESET} Profile name must use lowercase letters, numbers, "-", or "_" (e.g., "my-profile")`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Check if profile already exists
+  const existing = await listProfiles({ warn: false });
+  if (existing.some(p => p.name === name)) {
+    console.error(`${RED}Error:${RESET} Profile "${name}" already exists`);
+    process.exitCode = 1;
+    return;
+  }
+
+  let profileData: Profile;
+
+  if (template && TEMPLATES[template]) {
+    // Use template
+    profileData = { name, ...TEMPLATES[template] };
+    console.log(`${GREEN}✓${RESET} Created from template: ${template}`);
+  } else if (interactive) {
+    // Interactive mode - prompt for fields
+    profileData = await interactiveCreate(name);
+  } else {
+    // Minimal default
+    profileData = {
+      name,
+      description: `${name} profile`,
+      harness: "opencode",
+      info: `I am the ${name} profile. Describe my capabilities and purpose here.`,
+      config: {
+        workspace: { root: ".", policy: "current-directory" },
+        model: { provider: "default", id: "default", thinking: "default", cycle: [] },
+        prompt: `Use the ${name} profile.`,
+        resources: { skills: [], prompts: [], extensions: [], mcpServers: [] },
+        tools: { allow: [], deny: [] },
+        session: { dir: `.orkestrate/opencode-sessions/${name}` },
+      },
+    };
+    console.log(`${YELLOW}⚠${RESET} Created minimal profile. Edit with \`orkestrate\` TUI (press 'e') to customize.`);
+  }
+
+  // Validate
+  try {
+    parseProfile(profileData);
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Generated profile invalid:`, error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Save
+  try {
+    await saveProfile(profileData, { isGlobal: global });
+    const location = global ? "global (~/.orkestrate/profiles)" : "workspace (.orkestrate/profiles)";
+    console.log(`${GREEN}✓${RESET} Profile saved to ${location}`);
+    console.log("");
+    console.log(`Next steps:`);
+    console.log(`  orkestrate profile validate ${name}  # Verify configuration`);
+    console.log(`  orkestrate                             # Launch via TUI (select profile, press Enter)`);
+  } catch (error) {
+    console.error(`${RED}Error:${RESET} Failed to save profile:`, error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}
+
+async function interactiveCreate(name: string): Promise<Profile> {
+  // For now, return minimal - full interactive would need inquirer or similar
+  console.log("Interactive mode not fully implemented yet. Use --template or edit after creation.");
+  return {
+    name,
+    description: `${name} profile`,
+    harness: "opencode",
+    info: `I am the ${name} profile. Describe my capabilities and purpose here.`,
+    config: {
+      workspace: { root: ".", policy: "current-directory" },
+      model: { provider: "default", id: "default", thinking: "default", cycle: [] },
+      prompt: `Use the ${name} profile.`,
+      resources: { skills: [], prompts: [], extensions: [], mcpServers: [] },
+      tools: { allow: [], deny: [] },
+      session: { dir: `.orkestrate/opencode-sessions/${name}` },
+    },
+  };
+}