dic-workflow-kit 1.0.0

package/agents/repair-planner.md

@@ -0,0 +1,17 @@
+---
+name: repair-planner
+version: 1.0.0
+description: Create small, source-backed repair slices with target files, validation commands, stop conditions, and fallback plans.
+mode: subagent
+---
+
+You are the Repair Planner.
+
+Mission:
+
+- Convert confirmed gaps into small repair slices.
+- Preserve protected paths and public contracts.
+- Plan validation for each slice.
+- Avoid decorative subagent chains.
+
+Every repair item must include source anchor, target area, expected behavior, validation command, and stop condition.

package/agents/spec-reader.md

@@ -0,0 +1,23 @@
+---
+name: spec-reader
+version: 1.0.0
+description: Read authoritative design, OpenSpec, API, schema, README, and configuration sources and produce a source-backed requirement brief.
+mode: subagent
+---
+
+You are the Spec Reader.
+
+Mission:
+
+- Identify source truth.
+- Summarize requirements with file anchors.
+- Separate stable requirements from examples.
+- Mark ambiguity as `VERIFY`, not as implementation freedom.
+
+Output a handoff with:
+
+- sources read
+- requirement bullets
+- protected paths
+- unresolved questions
+- next recommended agent

package/agents/validation-runner.md

@@ -0,0 +1,16 @@
+---
+name: validation-runner
+version: 1.0.0
+description: Discover, run, and summarize project validation commands using evaluator-readable evidence.
+mode: subagent
+---
+
+You are the Validation Runner.
+
+Mission:
+
+- Prefer project-declared validation commands.
+- Resolve tools from PATH.
+- Store logs under `logs/trace/validation/`.
+- Wrap results into machine-readable summaries.
+- Classify missing tools as environment evidence.

package/bin/dic-workflow-kit.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PLUGIN_NAME = "dic-workflow-kit";
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const PAYLOAD = [
+  ".codex-plugin",
+  "adapters",
+  "agents",
+  "schemas",
+  "scripts",
+  "skills",
+  "INSTRUCTION.md",
+  "README.md",
+  "README.zh-CN.md",
+];
+
+function parseArgs(argv) {
+  const command = argv[0] ?? "help";
+  let marketplaceRoot = join(homedir(), ".agents", "plugins");
+  let dryRun = false;
+  for (let index = 1; index < argv.length; index += 1) {
+    const value = argv[index];
+    if (value === "--marketplace-root") {
+      const next = argv[index + 1];
+      if (!next) {
+        throw new Error("--marketplace-root requires a directory");
+      }
+      marketplaceRoot = resolve(next);
+      index += 1;
+    } else if (value === "--dry-run") {
+      dryRun = true;
+    } else {
+      throw new Error(`unknown argument: ${value}`);
+    }
+  }
+  return { command, marketplaceRoot: resolve(marketplaceRoot), dryRun };
+}
+
+async function loadMarketplace(path) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("marketplace.json must contain an object");
+    }
+    if (!Array.isArray(value.plugins)) {
+      throw new Error("marketplace.json must contain a plugins array");
+    }
+    return value;
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+    return {
+      name: "personal",
+      interface: { displayName: "Personal" },
+      plugins: [],
+    };
+  }
+}
+
+function pluginEntry() {
+  return {
+    name: PLUGIN_NAME,
+    source: {
+      source: "local",
+      path: `./plugins/${PLUGIN_NAME}`,
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL",
+    },
+    category: "Developer Tools",
+  };
+}
+
+async function install({ marketplaceRoot, dryRun }) {
+  const marketplacePath = join(marketplaceRoot, "marketplace.json");
+  const pluginRoot = join(marketplaceRoot, "plugins", PLUGIN_NAME);
+  const marketplace = await loadMarketplace(marketplacePath);
+  const entry = pluginEntry();
+  const existingIndex = marketplace.plugins.findIndex(
+    (candidate) => candidate?.name === PLUGIN_NAME,
+  );
+  if (existingIndex >= 0) {
+    marketplace.plugins[existingIndex] = entry;
+  } else {
+    marketplace.plugins.push(entry);
+  }
+
+  if (!dryRun) {
+    await mkdir(pluginRoot, { recursive: true });
+    for (const relativePath of PAYLOAD) {
+      await cp(join(PACKAGE_ROOT, relativePath), join(pluginRoot, relativePath), {
+        recursive: true,
+        force: true,
+      });
+    }
+    await mkdir(marketplaceRoot, { recursive: true });
+    await writeFile(
+      marketplacePath,
+      `${JSON.stringify(marketplace, null, 2)}\n`,
+      "utf8",
+    );
+  }
+
+  process.stdout.write(
+    [
+      dryRun ? "DRY_RUN: true" : "INSTALLED: true",
+      `PLUGIN_ROOT: ${pluginRoot}`,
+      `MARKETPLACE: ${marketplacePath}`,
+      "SKILLS: skills/",
+      "SUBAGENTS: agents/",
+      "",
+    ].join("\n"),
+  );
+}
+
+function printHelp() {
+  process.stdout.write(
+    [
+      "DIC Workflow Kit Codex installer",
+      "",
+      "Usage:",
+      "  dic-workflow-kit install [--marketplace-root <path>] [--dry-run]",
+      "",
+      "Default destination:",
+      "  ~/.agents/plugins/plugins/dic-workflow-kit",
+      "",
+    ].join("\n"),
+  );
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.command === "install") {
+    await install(options);
+  } else if (options.command === "help" || options.command === "--help") {
+    printHelp();
+  } else {
+    throw new Error(`unknown command: ${options.command}`);
+  }
+} catch (error) {
+  process.stderr.write(`ERROR: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "dic-workflow-kit",
+  "version": "1.0.0",
+  "description": "Install DIC Workflow Kit Skills and Subagents as a Codex plugin.",
+  "type": "module",
+  "bin": {
+    "dic-workflow-kit": "bin/dic-workflow-kit.mjs"
+  },
+  "scripts": {
+    "test": "python -m unittest discover -s tests -v && node --test tests/test_npm_installer.mjs",
+    "pack:check": "npm pack --dry-run"
+  },
+  "files": [
+    ".codex-plugin/",
+    "adapters/",
+    "agents/",
+    "bin/",
+    "schemas/",
+    "scripts/",
+    "!scripts/__pycache__/",
+    "!**/*.pyc",
+    "skills/",
+    "INSTRUCTION.md",
+    "README.md",
+    "README.zh-CN.md"
+  ],
+  "keywords": [
+    "codex",
+    "plugin",
+    "skills",
+    "subagents",
+    "openspec",
+    "bdd"
+  ],
+  "author": "TonyClaw",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitcode.com/TonyClaw/DICWorkflowKit.git"
+  },
+  "homepage": "https://gitcode.com/TonyClaw/DICWorkflowKit",
+  "engines": {
+    "node": ">=20"
+  }
+}

package/schemas/agent-handoff.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://dicworkflowkit.local/schemas/agent-handoff.schema.json",
+  "title": "DIC Agent Handoff",
+  "type": "object",
+  "required": ["schema", "agent", "version", "status", "inputsConsumed", "outputsProduced", "nextAction"],
+  "properties": {
+    "schema": { "const": "dic.agent-handoff.v1" },
+    "agent": { "type": "string" },
+    "version": { "type": "string" },
+    "status": { "enum": ["PASS", "HOLD", "FAIL", "SKIPPED_WITH_EVIDENCE"] },
+    "inputsConsumed": { "type": "array", "items": { "type": "string" } },
+    "outputsProduced": { "type": "array", "items": { "type": "string" } },
+    "traceArtifacts": { "type": "array", "items": { "type": "string" } },
+    "nextAction": { "type": "string" },
+    "blockers": { "type": "array", "items": { "type": "string" } },
+    "notes": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/contract-obligations.schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://dicworkflowkit.local/schemas/contract-obligations.schema.json",
+  "title": "DIC Contract Obligations",
+  "type": "object",
+  "required": ["schema", "version", "changeId", "changeLifecycle", "authorityPolicy", "sources", "counts", "obligations"],
+  "properties": {
+    "schema": { "const": "dic.contract-obligations.v1" },
+    "version": { "type": "string" },
+    "changeId": { "type": "string" },
+    "changeLifecycle": { "enum": ["active", "archived"] },
+    "authorityPolicy": { "type": "string" },
+    "sources": { "type": "array", "items": { "type": "string" } },
+    "counts": {
+      "type": "object",
+      "required": ["requirements", "scenarios", "total"],
+      "properties": {
+        "requirements": { "type": "integer", "minimum": 0 },
+        "scenarios": { "type": "integer", "minimum": 0 },
+        "total": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "obligations": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "capabilityId", "kind", "title", "statement", "source", "line", "authority", "parentId", "acceptanceClauses"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^obl-[0-9a-f]{12}$" },
+          "capabilityId": { "type": "string" },
+          "kind": { "enum": ["requirement", "scenario"] },
+          "title": { "type": "string" },
+          "statement": { "type": "string" },
+          "source": { "type": "string" },
+          "line": { "type": "integer", "minimum": 1 },
+          "authority": { "enum": ["active-change", "current-baseline"] },
+          "parentId": { "type": ["string", "null"] },
+          "acceptanceClauses": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["keyword", "text", "line"],
+              "properties": {
+                "keyword": { "enum": ["GIVEN", "WHEN", "THEN", "AND", "BUT"] },
+                "text": { "type": "string" },
+                "line": { "type": "integer", "minimum": 1 }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/schemas/final-result.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://dicworkflowkit.local/schemas/final-result.schema.json",
+  "title": "DIC Final Result",
+  "type": "object",
+  "required": ["schema", "status", "final", "summary", "artifacts"],
+  "properties": {
+    "schema": { "const": "dic.final-result.v1" },
+    "status": { "enum": ["PASS", "PARTIAL", "BLOCKED", "FAIL"] },
+    "final": { "type": "boolean" },
+    "summary": { "type": "string" },
+    "artifacts": { "type": "array", "items": { "type": "string" } },
+    "validation": { "type": "array", "items": { "type": "object" } },
+    "changedFiles": { "type": "array", "items": { "type": "string" } },
+    "residualRisks": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/schemas/project-profile.schema.json

@@ -0,0 +1,66 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://dicworkflowkit.local/schemas/project-profile.schema.json",
+  "title": "DIC Project Profile",
+  "type": "object",
+  "required": ["schema", "version", "projectRoot", "designSources", "implementationRoots", "testRoots", "validationCommands"],
+  "properties": {
+    "schema": { "const": "dic.project-profile.v1" },
+    "version": { "type": "string" },
+    "projectRoot": { "type": "string" },
+    "projectTypes": { "type": "array", "items": { "type": "string" } },
+    "adapters": { "type": "array", "items": { "type": "string" } },
+    "designEntry": {
+      "type": "object",
+      "required": ["type", "changeId", "lifecycle", "changeRoot", "documents", "deltaSpecs", "baselineSpecs"],
+      "properties": {
+        "type": { "const": "openspec-change" },
+        "changeId": { "type": "string" },
+        "lifecycle": { "enum": ["active", "archived"] },
+        "changeRoot": { "type": "string" },
+        "documents": { "type": "array", "items": { "type": "string" } },
+        "deltaSpecs": { "type": "array", "items": { "type": "string" } },
+        "baselineSpecs": { "type": "array", "items": { "type": "string" } },
+        "designMap": {
+          "type": "object",
+          "required": ["source", "capabilityId", "architectureDesigns", "moduleDesigns", "adrs", "validationSummary", "validationCommands"],
+          "properties": {
+            "source": { "type": "string" },
+            "capabilityId": { "type": "string" },
+            "architectureDesigns": { "type": "array", "items": { "type": "string" } },
+            "moduleDesigns": { "type": "array", "items": { "type": "string" } },
+            "adrs": { "type": "array", "items": { "type": "string" } },
+            "validationSummary": { "type": "string" },
+            "validationCommands": { "type": "array", "items": { "$ref": "#/$defs/validationCommand" } }
+          }
+        }
+      }
+    },
+    "deltaSpecs": { "type": "array", "items": { "type": "string" } },
+    "baselineSpecs": { "type": "array", "items": { "type": "string" } },
+    "designSources": { "type": "array", "items": { "type": "string" } },
+    "implementationRoots": { "type": "array", "items": { "type": "string" } },
+    "testRoots": { "type": "array", "items": { "type": "string" } },
+    "protectedPaths": { "type": "array", "items": { "type": "string" } },
+    "validationCommands": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/validationCommand" }
+    },
+    "riskFamilies": { "type": "array", "items": { "type": "string" } },
+    "outputContract": { "type": "object" }
+  },
+  "additionalProperties": true,
+  "$defs": {
+    "validationCommand": {
+      "type": "object",
+      "required": ["name", "command", "source"],
+      "properties": {
+        "name": { "type": "string" },
+        "command": { "type": "array", "items": { "type": "string" } },
+        "cwd": { "type": "string" },
+        "source": { "type": "string" },
+        "kind": { "type": "string" }
+      }
+    }
+  }
+}