skill-flow 1.0.0

package/src/adapters/channel-adapters.ts

@@ -0,0 +1,75 @@
+import path from "node:path";
+import type {
+  ChannelDetection,
+  DeploymentStrategy,
+  DeploymentTargetName,
+  LeafRecord,
+} from "../domain/types.js";
+import {
+  TARGET_DEFINITIONS,
+} from "../utils/constants.js";
+import { pathExists } from "../utils/fs.js";
+
+export interface ChannelAdapter {
+  readonly target: DeploymentTargetName;
+  readonly strategy: DeploymentStrategy;
+  detect(): Promise<ChannelDetection>;
+  resolveTargetPath(rootPath: string, linkName: string): string;
+}
+
+class DefaultChannelAdapter implements ChannelAdapter {
+  readonly strategy: DeploymentStrategy;
+
+  constructor(readonly target: DeploymentTargetName) {
+    this.strategy = TARGET_DEFINITIONS[target].strategy;
+  }
+
+  async detect(): Promise<ChannelDetection> {
+    const definition = TARGET_DEFINITIONS[this.target];
+    const envVar = definition.envVar;
+    const override = process.env[envVar];
+    const candidates = override ? [override] : definition.writeRootCandidates;
+
+    for (const candidate of candidates) {
+      const rootPath = path.resolve(candidate);
+      if (await pathExists(rootPath)) {
+        return {
+          target: this.target,
+          strategy: this.strategy,
+          available: true,
+          rootPath,
+        };
+      }
+    }
+
+    return {
+      target: this.target,
+      strategy: this.strategy,
+      available: false,
+      rootPath: path.resolve(candidates[0] ?? "."),
+      reason: `Target directory not found. Set ${envVar} or create the agent directory first.`,
+    };
+  }
+
+  resolveTargetPath(rootPath: string, linkName: string): string {
+    return path.join(rootPath, linkName);
+  }
+}
+
+export function createChannelAdapters(): ChannelAdapter[] {
+  return [
+    new DefaultChannelAdapter("claude-code"),
+    new DefaultChannelAdapter("codex"),
+    new DefaultChannelAdapter("cursor"),
+    new DefaultChannelAdapter("github-copilot"),
+    new DefaultChannelAdapter("gemini-cli"),
+    new DefaultChannelAdapter("opencode"),
+    new DefaultChannelAdapter("openclaw"),
+    new DefaultChannelAdapter("pi"),
+    new DefaultChannelAdapter("windsurf"),
+    new DefaultChannelAdapter("roo-code"),
+    new DefaultChannelAdapter("cline"),
+    new DefaultChannelAdapter("amp"),
+    new DefaultChannelAdapter("kiro"),
+  ];
+}

package/src/cli.tsx

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+import React from "react";
+import { Command } from "commander";
+import { render } from "ink";
+import { SkillFlowApp } from "./services/skill-flow.js";
+import { ConfigApp } from "./tui/config-app.js";
+import { formatActionSummary, formatDoctorIssue, formatWorkflowList } from "./utils/format.js";
+
+const program = new Command();
+const app = new SkillFlowApp();
+
+program
+  .name("skill-flow")
+  .description("Workflow-first skill projection manager")
+  .version("1.0.0");
+
+program
+  .command("add")
+  .argument("<source>", "Git source locator")
+  .action(async (source: string) => {
+    const result = await app.addSource(source);
+    if (!result.ok) {
+      printErrors(result.errors);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(
+      `Added ${result.data.manifest.id} with ${result.data.leafCount} valid skills.`,
+    );
+    printWarnings(result.warnings.map((warning) => warning.message));
+  });
+
+program.command("list").action(async () => {
+  const result = await app.listWorkflows();
+  if (!result.ok) {
+    printErrors(result.errors);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(formatWorkflowList(result.data.summaries));
+});
+
+program.command("config").action(async () => {
+  const result = await app.getConfigData();
+  if (!result.ok) {
+    printErrors(result.errors);
+    process.exitCode = 1;
+    return;
+  }
+
+  const initialDrafts = Object.fromEntries(
+    result.data.summaries.map((summary) => {
+      const targets = summary.bindings.targets;
+      const enabledTargets = Object.entries(targets)
+        .filter(([, value]) => value?.enabled)
+        .map(([target]) => target) as DraftBinding["enabledTargets"];
+      const selectedLeafIds = [...new Set(
+        enabledTargets.flatMap((target) => targets[target]?.leafIds ?? []),
+      )];
+      return [
+        summary.source.id,
+        {
+          enabledTargets,
+          selectedLeafIds,
+        },
+      ];
+    }),
+  );
+  const availableTargets = await app.getAvailableTargets();
+
+  const instance = render(
+    <ConfigApp
+      app={app}
+      availableTargets={availableTargets}
+      summaries={result.data.summaries}
+      initialDrafts={initialDrafts}
+    />,
+  );
+  await instance.waitUntilExit();
+});
+
+program
+  .command("update")
+  .argument("[sourceId]", "Optional workflow group id")
+  .option("--all", "Update all registered workflow groups")
+  .action(async (sourceId: string | undefined, options: { all?: boolean }) => {
+    const ids = options.all || !sourceId ? undefined : [sourceId];
+    const result = await app.updateSources(ids);
+    if (!result.ok) {
+      printErrors(result.errors);
+      process.exitCode = 1;
+      return;
+    }
+    for (const item of result.data.updated) {
+      console.log(
+        `${item.sourceId}  changed:${item.changed}  +${item.addedLeafIds.length}  -${item.removedLeafIds.length}  invalidated:${item.invalidatedLeafIds.length}`,
+      );
+    }
+    printWarnings(result.warnings.map((warning) => warning.message));
+  });
+
+program.command("doctor").action(async () => {
+  const result = await app.doctor();
+  if (!result.ok) {
+    printErrors(result.errors);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(result.data.status);
+  if (result.data.issues.length === 0) {
+    console.log("No issues detected.");
+    return;
+  }
+  for (const issue of result.data.issues) {
+    console.log(formatDoctorIssue(issue));
+  }
+});
+
+program
+  .command("uninstall")
+  .argument("<sourceIds...>", "Workflow group ids to remove")
+  .action(async (sourceIds: string[]) => {
+    const result = await app.uninstall(sourceIds);
+    if (!result.ok) {
+      printErrors(result.errors);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`Removed: ${result.data.removed.join(", ")}`);
+    printWarnings(result.data.warnings);
+  });
+
+await program.parseAsync(process.argv);
+
+function printErrors(errors: Array<{ message: string }>) {
+  for (const error of errors) {
+    console.error(error.message);
+  }
+}
+
+function printWarnings(messages: string[]) {
+  for (const message of messages) {
+    console.warn(`warning: ${message}`);
+  }
+}
+
+type DraftBinding = import("./services/skill-flow.js").DraftBinding;

package/src/domain/types.ts

@@ -0,0 +1,175 @@
+export type Warning = {
+  code: string;
+  message: string;
+};
+
+export type Failure = {
+  code: string;
+  message: string;
+};
+
+export type Result<T> =
+  | { ok: true; data: T; warnings: Warning[]; errors: [] }
+  | { ok: false; data?: T; warnings: Warning[]; errors: Failure[] };
+
+export type SourceKind = "git";
+
+export type DeploymentTargetName =
+  | "claude-code"
+  | "codex"
+  | "cursor"
+  | "github-copilot"
+  | "gemini-cli"
+  | "opencode"
+  | "openclaw"
+  | "pi"
+  | "windsurf"
+  | "roo-code"
+  | "cline"
+  | "amp"
+  | "kiro";
+
+export type DeploymentStrategy = "symlink" | "copy";
+
+export type HealthStatus =
+  | "HEALTHY"
+  | "ACTIVE"
+  | "INACTIVE"
+  | "PARTIAL"
+  | "BLOCKED"
+  | "INVALID"
+  | "UPDATE AVAILABLE"
+  | "UP TO DATE"
+  | "DRIFT DETECTED";
+
+export type SourceManifestRecord = {
+  id: string;
+  locator: string;
+  kind: SourceKind;
+  displayName: string;
+  addedAt: string;
+};
+
+export type TargetBinding = {
+  enabled: boolean;
+  leafIds: string[];
+};
+
+export type SourceBinding = {
+  targets: Partial<Record<DeploymentTargetName, TargetBinding>>;
+};
+
+export type Manifest = {
+  schemaVersion: 1;
+  sources: SourceManifestRecord[];
+  bindings: Record<string, SourceBinding>;
+};
+
+export type InvalidLeafRecord = {
+  path: string;
+  reason: string;
+};
+
+export type SourceLockRecord = {
+  id: string;
+  locator: string;
+  kind: SourceKind;
+  displayName: string;
+  checkoutPath: string;
+  commitSha: string;
+  updatedAt: string;
+  leafIds: string[];
+  invalidLeafs: InvalidLeafRecord[];
+};
+
+export type LeafRecord = {
+  id: string;
+  sourceId: string;
+  name: string;
+  linkName: string;
+  title: string;
+  description: string;
+  relativePath: string;
+  absolutePath: string;
+  skillFilePath: string;
+  contentHash: string;
+  metadataWarnings: string[];
+  valid: true;
+};
+
+export type DeploymentRecord = {
+  sourceId: string;
+  leafId: string;
+  target: DeploymentTargetName;
+  targetPath: string;
+  strategy: DeploymentStrategy;
+  status: "active" | "drifted" | "blocked" | "removed";
+  contentHash: string;
+  appliedAt: string;
+};
+
+export type LockFile = {
+  schemaVersion: 1;
+  sources: SourceLockRecord[];
+  leafInventory: LeafRecord[];
+  deployments: DeploymentRecord[];
+};
+
+export type ChannelDetection = {
+  target: DeploymentTargetName;
+  strategy: DeploymentStrategy;
+  available: boolean;
+  rootPath: string;
+  reason?: string;
+};
+
+export type DeploymentActionKind =
+  | "create"
+  | "update"
+  | "remove"
+  | "noop"
+  | "blocked";
+
+export type DeploymentAction = {
+  kind: DeploymentActionKind;
+  sourceId: string;
+  leafId: string;
+  target: DeploymentTargetName;
+  strategy: DeploymentStrategy;
+  sourcePath: string;
+  targetPath: string;
+  previousTargetPath?: string;
+  reason?: string;
+  contentHash: string;
+};
+
+export type DeploymentPlan = {
+  actions: DeploymentAction[];
+  warnings: Warning[];
+  blocked: DeploymentAction[];
+};
+
+export type DoctorIssueSeverity = "info" | "warning" | "error";
+
+export type DoctorIssue = {
+  severity: DoctorIssueSeverity;
+  sourceId: string;
+  target?: DeploymentTargetName;
+  leafId?: string;
+  code: string;
+  message: string;
+};
+
+export type DoctorReport = {
+  status: "HEALTHY" | "PARTIAL" | "BLOCKED";
+  issues: DoctorIssue[];
+};
+
+export type WorkflowSummary = {
+  source: SourceManifestRecord;
+  lock: SourceLockRecord | undefined;
+  leafs: LeafRecord[];
+  bindings: SourceBinding;
+  activeTargetCount: number;
+  health: HealthStatus;
+};

package/src/services/deployment-applier.ts

@@ -0,0 +1,81 @@
+import path from "node:path";
+import type {
+  DeploymentAction,
+  DeploymentRecord,
+  LockFile,
+  Result,
+} from "../domain/types.js";
+import { copyDirectory, createSymlink, ensureDir, pathExists, removePath } from "../utils/fs.js";
+import { ok } from "../utils/result.js";
+
+export class DeploymentApplier {
+  async applyPlan(
+    lockFile: LockFile,
+    actions: DeploymentAction[],
+  ): Promise<Result<{ applied: DeploymentAction[] }>> {
+    const applied: DeploymentAction[] = [];
+
+    for (const action of actions) {
+      if (action.kind === "blocked" || action.kind === "noop") {
+        continue;
+      }
+
+      if (action.kind === "remove") {
+        if (await pathExists(action.targetPath)) {
+          await removePath(action.targetPath);
+        }
+        lockFile.deployments = lockFile.deployments.filter(
+          (deployment) =>
+            !(
+              deployment.sourceId === action.sourceId &&
+              deployment.leafId === action.leafId &&
+              deployment.target === action.target
+            ),
+        );
+        applied.push(action);
+        continue;
+      }
+
+      await ensureDir(path.dirname(action.targetPath));
+      if (
+        action.previousTargetPath &&
+        action.previousTargetPath !== action.targetPath &&
+        (await pathExists(action.previousTargetPath))
+      ) {
+        await removePath(action.previousTargetPath);
+      }
+
+      if (action.strategy === "symlink") {
+        await createSymlink(action.sourcePath, action.targetPath);
+      } else {
+        await copyDirectory(action.sourcePath, action.targetPath);
+      }
+
+      const nextRecord: DeploymentRecord = {
+        sourceId: action.sourceId,
+        leafId: action.leafId,
+        target: action.target,
+        targetPath: action.targetPath,
+        strategy: action.strategy,
+        status: "active",
+        contentHash: action.contentHash,
+        appliedAt: new Date().toISOString(),
+      };
+
+      lockFile.deployments = [
+        ...lockFile.deployments.filter(
+          (deployment) =>
+            !(
+              deployment.sourceId === action.sourceId &&
+              deployment.leafId === action.leafId &&
+              deployment.target === action.target
+            ),
+        ),
+        nextRecord,
+      ];
+      applied.push(action);
+    }
+
+    return ok({ applied });
+  }
+}