@full-self-developing/fsd 1.0.0

package/extensions/skill-workshop/src/signals.ts

@@ -0,0 +1,95 @@
+import { randomUUID } from "node:crypto";
+import { compactWhitespace, extractTranscriptText } from "./text.js";
+import type { SkillProposal } from "./types.js";
+
+const CORRECTION_PATTERNS = [
+  /\bnext time\b/i,
+  /\bfrom now on\b/i,
+  /\bremember to\b/i,
+  /\bmake sure to\b/i,
+  /\balways\b.{0,80}\b(use|check|verify|record|save|prefer)\b/i,
+  /\bprefer\b.{0,120}\b(when|for|instead|use)\b/i,
+  /\bwhen asked\b/i,
+];
+
+function inferTopic(text: string): { skillName: string; title: string; label: string } {
+  const lower = text.toLowerCase();
+  if (/\banimated\b|\bgifs?\b/.test(lower)) {
+    return {
+      skillName: "animated-gif-workflow",
+      title: "Animated GIF Workflow",
+      label: "animated GIF requests",
+    };
+  }
+  if (/\bscreenshot|screen capture|imageoptim|asset\b/.test(lower)) {
+    return {
+      skillName: "screenshot-asset-workflow",
+      title: "Screenshot Asset Workflow",
+      label: "screenshot asset updates",
+    };
+  }
+  if (/\bqa\b|\bscenario\b|\btest plan\b/.test(lower)) {
+    return { skillName: "qa-scenario-workflow", title: "QA Scenario Workflow", label: "QA tasks" };
+  }
+  if (/\bpr\b|\bpull request\b|\bgithub\b/.test(lower)) {
+    return {
+      skillName: "github-pr-workflow",
+      title: "GitHub PR Workflow",
+      label: "GitHub PR work",
+    };
+  }
+  return { skillName: "learned-workflows", title: "Learned Workflows", label: "repeatable tasks" };
+}
+
+function extractInstruction(text: string): string | undefined {
+  const trimmed = compactWhitespace(text);
+  if (trimmed.length < 24 || trimmed.length > 1200) {
+    return undefined;
+  }
+  if (!CORRECTION_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+    return undefined;
+  }
+  return trimmed.replace(/^ok[,. ]+/i, "");
+}
+
+export function createProposalFromMessages(params: {
+  messages: unknown[];
+  workspaceDir: string;
+  agentId?: string;
+  sessionId?: string;
+}): SkillProposal | undefined {
+  const transcript = extractTranscriptText(params.messages);
+  const userTexts = transcript.filter((entry) => entry.role === "user").map((entry) => entry.text);
+  const instruction = userTexts.map(extractInstruction).findLast(Boolean);
+  if (!instruction) {
+    return undefined;
+  }
+  const topic = inferTopic(instruction);
+  const now = Date.now();
+  return {
+    id: randomUUID(),
+    createdAt: now,
+    updatedAt: now,
+    workspaceDir: params.workspaceDir,
+    ...(params.agentId ? { agentId: params.agentId } : {}),
+    ...(params.sessionId ? { sessionId: params.sessionId } : {}),
+    skillName: topic.skillName,
+    title: topic.title,
+    reason: `User correction for ${topic.label}`,
+    source: "agent_end",
+    status: "pending",
+    change: {
+      kind: "create",
+      description: `Reusable workflow notes for ${topic.label}.`,
+      body: [
+        `# ${topic.title}`,
+        "",
+        "## Workflow",
+        "",
+        `- ${instruction}`,
+        "- Verify the result before final reply.",
+        "- Record durable pitfalls as short bullets; avoid copying transcript noise.",
+      ].join("\n"),
+    },
+  };
+}

package/extensions/skill-workshop/src/skills.ts

@@ -0,0 +1,186 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  pathExists,
+  replaceFileAtomic,
+  resolvePathWithinRoot,
+} from "openclaw/plugin-sdk/security-runtime";
+import { bumpSkillsSnapshotVersion } from "../api.js";
+import { assertSkillContentSafe, scanSkillContent } from "./scanner.js";
+import type { SkillProposal, SkillScanFinding } from "./types.js";
+
+const VALID_SKILL_NAME = /^[a-z0-9][a-z0-9_-]{1,79}$/;
+const VALID_SECTION = /^[A-Za-z0-9][A-Za-z0-9 _./:-]{0,80}$/;
+const SUPPORT_DIRS = new Set(["references", "templates", "scripts", "assets"]);
+
+export function normalizeSkillName(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^[^a-z0-9]+/, "")
+    .replace(/[^a-z0-9]+$/, "")
+    .slice(0, 80);
+}
+
+function assertValidSkillName(name: string): string {
+  const normalized = normalizeSkillName(name);
+  if (!VALID_SKILL_NAME.test(normalized)) {
+    throw new Error(`invalid skill name: ${name}`);
+  }
+  return normalized;
+}
+
+function assertValidSection(section: string): string {
+  const trimmed = section.trim();
+  if (!VALID_SECTION.test(trimmed)) {
+    throw new Error(`invalid section: ${section}`);
+  }
+  return trimmed;
+}
+
+function skillDir(workspaceDir: string, skillName: string): string {
+  const safeName = assertValidSkillName(skillName);
+  const root = path.resolve(workspaceDir, "skills");
+  const dir = resolvePathWithinRoot({
+    rootDir: root,
+    requestedPath: safeName,
+    scopeLabel: "workspace skills directory",
+  });
+  if (!dir.ok) {
+    throw new Error("skill path escapes workspace skills directory");
+  }
+  return dir.path;
+}
+
+function skillPath(workspaceDir: string, skillName: string): string {
+  return path.join(skillDir(workspaceDir, skillName), "SKILL.md");
+}
+
+async function atomicWrite(filePath: string, content: string): Promise<void> {
+  await replaceFileAtomic({
+    filePath,
+    content,
+    tempPrefix: ".skill-workshop",
+  });
+}
+
+function formatSkillMarkdown(params: { name: string; description: string; body: string }): string {
+  const description = params.description.replace(/\s+/g, " ").trim();
+  if (!description) {
+    throw new Error("description required");
+  }
+  const body = params.body.trim();
+  return `---\nname: ${params.name}\ndescription: ${description}\n---\n\n${body}\n`;
+}
+
+function ensureBodyUnderLimit(content: string, maxSkillBytes: number): void {
+  if (Buffer.byteLength(content, "utf8") > maxSkillBytes) {
+    throw new Error(`skill exceeds ${maxSkillBytes} bytes`);
+  }
+}
+
+function appendSection(markdown: string, section: string, body: string): string {
+  const heading = `## ${assertValidSection(section)}`;
+  const trimmedBody = body.trim();
+  if (!trimmedBody) {
+    throw new Error("body required");
+  }
+  if (markdown.includes(trimmedBody)) {
+    return markdown.endsWith("\n") ? markdown : `${markdown}\n`;
+  }
+  if (!markdown.includes(heading)) {
+    return `${markdown.trimEnd()}\n\n${heading}\n\n${trimmedBody}\n`;
+  }
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return markdown.replace(new RegExp(`(${escaped}\\n)`), `$1\n${trimmedBody}\n`);
+}
+
+export async function prepareProposalWrite(params: {
+  proposal: SkillProposal;
+  maxSkillBytes: number;
+}): Promise<{
+  skillPath: string;
+  content: string;
+  created: boolean;
+  findings: SkillScanFinding[];
+}> {
+  const name = assertValidSkillName(params.proposal.skillName);
+  const target = skillPath(params.proposal.workspaceDir, name);
+  const exists = await pathExists(target);
+  let next: string;
+  const change = params.proposal.change;
+  if (change.kind === "create") {
+    next = exists
+      ? appendSection(await fs.readFile(target, "utf8"), "Workflow", change.body)
+      : formatSkillMarkdown({ name, description: change.description, body: change.body });
+  } else if (change.kind === "append") {
+    const current = exists
+      ? await fs.readFile(target, "utf8")
+      : formatSkillMarkdown({
+          name,
+          description: change.description ?? params.proposal.title,
+          body: "# Workflow\n",
+        });
+    next = appendSection(current, change.section, change.body);
+  } else {
+    if (!exists) {
+      throw new Error(`skill does not exist: ${name}`);
+    }
+    const current = await fs.readFile(target, "utf8");
+    if (!current.includes(change.oldText)) {
+      throw new Error("oldText not found");
+    }
+    next = current.replace(change.oldText, change.newText);
+  }
+  ensureBodyUnderLimit(next, params.maxSkillBytes);
+  const findings = scanSkillContent(next);
+  return { skillPath: target, content: next, created: !exists, findings };
+}
+
+export async function applyProposalToWorkspace(params: {
+  proposal: SkillProposal;
+  maxSkillBytes: number;
+}): Promise<{ skillPath: string; created: boolean; findings: SkillScanFinding[] }> {
+  const prepared = await prepareProposalWrite(params);
+  assertSkillContentSafe(prepared.content);
+  await atomicWrite(prepared.skillPath, prepared.content);
+  bumpSkillsSnapshotVersion({
+    workspaceDir: params.proposal.workspaceDir,
+    reason: "manual",
+    changedPath: prepared.skillPath,
+  });
+  return { skillPath: prepared.skillPath, created: prepared.created, findings: prepared.findings };
+}
+
+export async function writeSupportFile(params: {
+  workspaceDir: string;
+  skillName: string;
+  relativePath: string;
+  content: string;
+  maxBytes: number;
+}): Promise<string> {
+  const name = assertValidSkillName(params.skillName);
+  const parts = params.relativePath.split(/[\\/]+/).filter(Boolean);
+  if (parts.length < 2 || !SUPPORT_DIRS.has(parts[0])) {
+    throw new Error(`support file path must start with ${Array.from(SUPPORT_DIRS).join(", ")}`);
+  }
+  if (parts.some((part) => part === "." || part === "..")) {
+    throw new Error("support file path escapes skill directory");
+  }
+  if (Buffer.byteLength(params.content, "utf8") > params.maxBytes) {
+    throw new Error(`support file exceeds ${params.maxBytes} bytes`);
+  }
+  assertSkillContentSafe(params.content);
+  const root = skillDir(params.workspaceDir, name);
+  const target = resolvePathWithinRoot({
+    rootDir: root,
+    requestedPath: path.join(...parts),
+    scopeLabel: "skill directory",
+  });
+  if (!target.ok) {
+    throw new Error("support file path escapes skill directory");
+  }
+  await atomicWrite(target.path, `${params.content.trimEnd()}\n`);
+  return target.path;
+}

package/extensions/skill-workshop/src/store.ts

@@ -0,0 +1,184 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { privateFileStore } from "openclaw/plugin-sdk/security-runtime";
+import type { SkillProposal, SkillWorkshopStatus } from "./types.js";
+
+type StoreFile = {
+  version: 1;
+  proposals: SkillProposal[];
+  review?: SkillWorkshopReviewState;
+};
+
+type SkillWorkshopReviewState = {
+  turnsSinceReview: number;
+  toolCallsSinceReview: number;
+  lastReviewAt?: number;
+};
+
+const locks = new Map<string, Promise<void>>();
+
+function workspaceKey(workspaceDir: string): string {
+  return createHash("sha256").update(path.resolve(workspaceDir)).digest("hex").slice(0, 16);
+}
+
+async function withLock<T>(key: string, task: () => Promise<T>): Promise<T> {
+  const previous = locks.get(key) ?? Promise.resolve();
+  let release: (() => void) | undefined;
+  const next = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  locks.set(
+    key,
+    previous.then(() => next),
+  );
+  await previous;
+  try {
+    return await task();
+  } finally {
+    release?.();
+    if (locks.get(key) === next) {
+      locks.delete(key);
+    }
+  }
+}
+
+async function readJson(rootDir: string, relativePath: string): Promise<StoreFile> {
+  const parsed = await privateFileStore(rootDir).readJsonIfExists<StoreFile>(relativePath);
+  if (!parsed) {
+    return { version: 1, proposals: [] };
+  }
+  return {
+    version: 1,
+    proposals: Array.isArray(parsed.proposals) ? parsed.proposals : [],
+    review:
+      parsed.review && typeof parsed.review === "object"
+        ? normalizeReviewState(parsed.review as Partial<SkillWorkshopReviewState>)
+        : undefined,
+  };
+}
+
+function normalizeReviewState(
+  value: Partial<SkillWorkshopReviewState> = {},
+): SkillWorkshopReviewState {
+  return {
+    turnsSinceReview:
+      typeof value.turnsSinceReview === "number" && Number.isFinite(value.turnsSinceReview)
+        ? Math.max(0, Math.trunc(value.turnsSinceReview))
+        : 0,
+    toolCallsSinceReview:
+      typeof value.toolCallsSinceReview === "number" && Number.isFinite(value.toolCallsSinceReview)
+        ? Math.max(0, Math.trunc(value.toolCallsSinceReview))
+        : 0,
+    ...(typeof value.lastReviewAt === "number" && Number.isFinite(value.lastReviewAt)
+      ? { lastReviewAt: value.lastReviewAt }
+      : {}),
+  };
+}
+
+async function atomicWriteJson(
+  rootDir: string,
+  relativePath: string,
+  data: StoreFile,
+): Promise<void> {
+  await privateFileStore(rootDir).writeJson(relativePath, data, {
+    trailingNewline: true,
+  });
+}
+
+export class SkillWorkshopStore {
+  readonly stateDir: string;
+  readonly filePath: string;
+  private readonly relativePath: string;
+
+  constructor(params: { stateDir: string; workspaceDir: string }) {
+    this.stateDir = path.resolve(params.stateDir);
+    this.relativePath = path.join("skill-workshop", `${workspaceKey(params.workspaceDir)}.json`);
+    this.filePath = path.join(this.stateDir, this.relativePath);
+  }
+
+  async list(status?: SkillWorkshopStatus): Promise<SkillProposal[]> {
+    const file = await readJson(this.stateDir, this.relativePath);
+    const proposals = status
+      ? file.proposals.filter((proposal) => proposal.status === status)
+      : file.proposals;
+    return proposals.toSorted((left, right) => right.createdAt - left.createdAt);
+  }
+
+  async get(id: string): Promise<SkillProposal | undefined> {
+    return (await this.list()).find((proposal) => proposal.id === id);
+  }
+
+  async add(proposal: SkillProposal, maxPending: number): Promise<SkillProposal> {
+    return await withLock(this.filePath, async () => {
+      const file = await readJson(this.stateDir, this.relativePath);
+      const duplicate = file.proposals.find(
+        (item) =>
+          (item.status === "pending" || item.status === "quarantined") &&
+          item.skillName === proposal.skillName &&
+          JSON.stringify(item.change) === JSON.stringify(proposal.change),
+      );
+      if (duplicate) {
+        return duplicate;
+      }
+      const nextProposals = [proposal, ...file.proposals].filter((item, index, all) => {
+        if (item.status !== "pending" && item.status !== "quarantined") {
+          return true;
+        }
+        return (
+          all
+            .slice(0, index + 1)
+            .filter(
+              (candidate) => candidate.status === "pending" || candidate.status === "quarantined",
+            ).length <= maxPending
+        );
+      });
+      await atomicWriteJson(this.stateDir, this.relativePath, {
+        ...file,
+        version: 1,
+        proposals: nextProposals,
+      });
+      return proposal;
+    });
+  }
+
+  async updateStatus(id: string, status: SkillWorkshopStatus): Promise<SkillProposal> {
+    return await withLock(this.filePath, async () => {
+      const file = await readJson(this.stateDir, this.relativePath);
+      const index = file.proposals.findIndex((proposal) => proposal.id === id);
+      if (index < 0) {
+        throw new Error(`proposal not found: ${id}`);
+      }
+      const updated = { ...file.proposals[index], status, updatedAt: Date.now() };
+      file.proposals[index] = updated;
+      await atomicWriteJson(this.stateDir, this.relativePath, file);
+      return updated;
+    });
+  }
+
+  async recordReviewTurn(toolCalls: number): Promise<SkillWorkshopReviewState> {
+    return await withLock(this.filePath, async () => {
+      const file = await readJson(this.stateDir, this.relativePath);
+      const current = normalizeReviewState(file.review);
+      const next = {
+        ...current,
+        turnsSinceReview: current.turnsSinceReview + 1,
+        toolCallsSinceReview: current.toolCallsSinceReview + Math.max(0, Math.trunc(toolCalls)),
+      };
+      await atomicWriteJson(this.stateDir, this.relativePath, { ...file, review: next });
+      return next;
+    });
+  }
+
+  async markReviewed(): Promise<SkillWorkshopReviewState> {
+    return await withLock(this.filePath, async () => {
+      const file = await readJson(this.stateDir, this.relativePath);
+      const next = {
+        turnsSinceReview: 0,
+        toolCallsSinceReview: 0,
+        lastReviewAt: Date.now(),
+      };
+      await atomicWriteJson(this.stateDir, this.relativePath, { ...file, review: next });
+      return next;
+    });
+  }
+}

package/extensions/skill-workshop/src/text.ts

@@ -0,0 +1,59 @@
+const TEXT_BLOCK_TYPES = new Set(["text", "input_text", "output_text"]);
+
+function readTextValue(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (
+    value &&
+    typeof value === "object" &&
+    typeof (value as { value?: unknown }).value === "string"
+  ) {
+    return (value as { value: string }).value;
+  }
+  return "";
+}
+
+function extractTextBlock(block: unknown): string {
+  if (!block || typeof block !== "object") {
+    return "";
+  }
+  const type = (block as { type?: unknown }).type;
+  if (typeof type !== "string" || !TEXT_BLOCK_TYPES.has(type)) {
+    return "";
+  }
+  return readTextValue((block as { text?: unknown }).text);
+}
+
+function extractMessageText(content: unknown): string {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map(extractTextBlock).filter(Boolean).join("\n");
+  }
+  return extractTextBlock(content);
+}
+
+export function extractTranscriptText(messages: unknown[]): Array<{ role: string; text: string }> {
+  const result: Array<{ role: string; text: string }> = [];
+  for (const message of messages) {
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+    const role = (message as { role?: unknown }).role;
+    const content = (message as { content?: unknown }).content;
+    if (typeof role !== "string") {
+      continue;
+    }
+    const text = extractMessageText(content).trim();
+    if (text) {
+      result.push({ role, text });
+    }
+  }
+  return result;
+}
+
+export function compactWhitespace(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}