@gobing-ai/knowledge-kit 0.0.7 → 0.0.8

package/plugins/kk/workflows/kk-solo-podcast.yaml

@@ -0,0 +1,374 @@
+---
+"$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
+name: kk-solo-podcast
+kind: state-machine
+description: >-
+  Solo podcast authoring pipeline using VoiceScript authoring, Spur HITL gates, and voice-gen audio generation
+initialState: prepare
+terminalStates:
+  - done
+  - failed
+failureStates:
+  - failed
+
+vars:
+  topic: ""
+  input_file: ""
+  work_dir: ""
+  force: "false"
+  outline: ""
+  script_approved: ""
+  target_duration_min: "8"
+  words_per_min: "150"
+  cjk_chars_per_min: "220"
+  voice_profile: ""
+  language: "en"
+  plugins_path: ""
+  validate_script: ""
+  agent: ""
+  __runId: "solo"
+  __hitlAnswer: ""
+  __hitlInput: ""
+
+states:
+  - id: prepare
+    description: "mkdir work_dir and stage subdirectories; validate XOR topic/input_file and voice_profile; write brief.md"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set -e;
+            if [ -z "${vars.work_dir}" ]; then
+              echo "missing work_dir" >&2; exit 1;
+            fi;
+            mkdir -p "${vars.work_dir}" "${vars.work_dir}/1-briefing" "${vars.work_dir}/2-outline" "${vars.work_dir}/3-script" "${vars.work_dir}/4-audio";
+            if [ -n "${vars.topic}" ] && [ -n "${vars.input_file}" ]; then
+              echo "XOR violation: both topic and input_file set" >&2; exit 1;
+            fi;
+            if [ -z "${vars.topic}" ] && [ -z "${vars.input_file}" ]; then
+              echo "XOR violation: neither topic nor input_file set" >&2; exit 1;
+            fi;
+            if [ -z "${vars.voice_profile}" ] && [ -z "$VOICEBOX_DEFAULT_PROFILE" ]; then
+              echo "missing voice_profile (set vars.voice_profile or VOICEBOX_DEFAULT_PROFILE)" >&2; exit 1;
+            fi;
+            if [ -f "${vars.work_dir}/brief.md" ] && [ "${vars.force}" != "true" ]; then
+              echo "initialization target already exists at ${vars.work_dir}/brief.md; pass force=true to replace" >&2; exit 1;
+            fi;
+            if [ -n "${vars.topic}" ]; then
+              printf '%s\n' "${vars.topic}" > "${vars.work_dir}/brief.md";
+            else
+              if [ ! -f "${vars.input_file}" ]; then
+                echo "input file not found: ${vars.input_file}" >&2; exit 1;
+              fi;
+              cp "${vars.input_file}" "${vars.work_dir}/brief.md";
+            fi;
+
+  - id: understand
+    description: "Analyze brief and generate podcast briefing (agent.run)"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Read the source brief at ${vars.work_dir}/brief.md.
+            Write a concise podcast briefing at ${vars.work_dir}/1-briefing/briefing.md.
+            Identify core thesis, key listener takeaways, audience profile, target spoken duration (${vars.target_duration_min} minutes), tone, and what material from the brief to emphasize or cut.
+          expectFile: ${vars.work_dir}/1-briefing/briefing.md
+
+  - id: outline-write
+    description: "Generate spoken podcast outline options (agent.run)"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Read the briefing at ${vars.work_dir}/1-briefing/briefing.md and brief at ${vars.work_dir}/brief.md.
+            Generate spoken podcast outline options in ${vars.work_dir}/2-outline/:
+            - outline-option-a.md (e.g. narrative / storytelling arc)
+            - outline-option-b.md (e.g. analytical / explainer breakdown)
+            - optional outline-option-c.md
+            Target total episode spoken duration is ${vars.target_duration_min} minutes.
+            Do not wait for operator selection; write the option files.
+          expectFile: ${vars.work_dir}/2-outline/outline-option-a.md
+      - kind: shell
+        options:
+          command: >-
+            test -f "${vars.work_dir}/2-outline/outline-option-b.md" || { echo "missing required outline-option-b.md" >&2; exit 1; }
+
+  - id: outline-select
+    description: "Operator selects preferred outline option"
+    pause: true
+    onEnter:
+      - kind: hitl.select
+        options:
+          prompt: "Select an approved outline option from ${vars.work_dir}/2-outline/ (outline-option-a.md, outline-option-b.md, or outline-option-c.md):"
+          options:
+            - a
+            - b
+            - c
+          var: __hitlAnswer
+
+  - id: outline-commit
+    description: "Copy selected outline to outline-approved.md"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            sel="${vars.outline}";
+            if [ -z "$sel" ]; then sel="${vars.__hitlAnswer}"; fi;
+            if [ -z "$sel" ]; then sel="a"; fi;
+            src="${vars.work_dir}/2-outline/outline-option-$sel.md";
+            if [ ! -f "$src" ]; then
+              echo "selected outline file not found: $src" >&2; exit 1;
+            fi;
+            cp "$src" "${vars.work_dir}/2-outline/outline-approved.md";
+
+  - id: script-write
+    description: "Author complete VoiceScript YAML from approved outline (agent.run)"
+    onEnter:
+      - kind: agent.run
+        options:
+          role: scribe
+          agent: ${vars.agent}
+          input: |
+            Read the approved outline at ${vars.work_dir}/2-outline/outline-approved.md and briefing at ${vars.work_dir}/1-briefing/briefing.md.
+            Target duration is ${vars.target_duration_min} minutes.
+            Spoken budget: if language (${vars.language}) is zh, ja, or ko, target characters = ${vars.target_duration_min} * ${vars.cjk_chars_per_min}; otherwise target words = ${vars.target_duration_min} * ${vars.words_per_min}. Land inside ±20%, spoken prose, one speaker.
+            Author the complete solo-podcast VoiceScript YAML at ${vars.work_dir}/3-script/voicescript.yaml.
+            Emit ONLY valid YAML (no markdown fences, no repo/docs paths). Contract:
+            title: string
+            language: "${vars.language}"
+            default_profile: "${vars.voice_profile}"
+            default_engine: qwen|qwen_custom_voice|luxtts|chatterbox|chatterbox_turbo|tada|kokoro  # optional
+            segments:
+              - text: "spoken sentence"   # required, 1..50000 characters
+                gap_ms: 400               # optional, >= 0, silence before next clip
+                instruct: "warm"          # optional, <= 500 characters
+            Do not invent fields. Revision feedback: ${vars.__hitlInput}
+          expectFile: ${vars.work_dir}/3-script/voicescript.yaml
+
+  - id: script-validate
+    description: "Validate authored VoiceScript YAML structure and constraints"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set -e;
+            vs="${vars.validate_script}";
+            if [ -z "$vs" ]; then
+              if [ -n "$KK_WORKFLOWS_DIR" ]; then vs="$KK_WORKFLOWS_DIR/validate-voicescript.ts";
+              else vs="$HOME/.config/kk/workflows/validate-voicescript.ts"; fi;
+            fi;
+            if [ ! -f "$vs" ]; then
+              echo "validate_script not found: $vs (install with /workflow-run kk-solo-podcast into $HOME/.config/kk/workflows)" >&2;
+              exit 1;
+            fi;
+            bun "$vs" --in "${vars.work_dir}/3-script/voicescript.yaml"
+
+  - id: script-review
+    description: "Operator reviews and approves VoiceScript before live TTS generation"
+    pause: true
+    onEnter:
+      - kind: hitl.confirm
+        options:
+          prompt: "Review VoiceScript at ${vars.work_dir}/3-script/voicescript.yaml. Approve for voice generation?"
+          var: __hitlAnswer
+
+  - id: script-revise
+    description: "Collect revision feedback from operator (bounded by 3 rounds)"
+    pause: true
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p .spur/run;
+            run_id="${vars.__runId}";
+            if [ -z "$run_id" ]; then run_id="solo"; fi;
+            count_file=".spur/run/$run_id-solo-revise-count";
+            curr=$(cat "$count_file" 2>/dev/null || echo 0);
+            echo $((curr + 1)) > "$count_file";
+      - kind: hitl.input
+        options:
+          prompt: "Provide specific revision feedback for ${vars.work_dir}/3-script/voicescript.yaml:"
+          var: __hitlInput
+
+  - id: wrap-docs
+    description: "Wrap VoiceScript into Doc[] JSON for voice-gen generator plugin"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            bun -e '
+            import { readFileSync, writeFileSync } from "node:fs";
+            import { createHash } from "node:crypto";
+            import { resolve } from "node:path";
+            const scriptPath = resolve(process.argv[1]);
+            const outPath = resolve(process.argv[2]);
+            const voiceProfile = process.argv[3] || process.env.VOICEBOX_DEFAULT_PROFILE || "";
+            const body = readFileSync(scriptPath, "utf-8");
+            const sourceUri = "file://" + scriptPath;
+            const id = createHash("sha256").update(sourceUri).digest("hex").slice(0, 16);
+            const doc = {
+              id,
+              title: "Podcast VoiceScript",
+              sourceUri,
+              body,
+              mediaType: "application/yaml",
+              metadata: voiceProfile ? { voiceProfile } : {},
+            };
+            writeFileSync(outPath, JSON.stringify([doc], null, 2));
+            ' "${vars.work_dir}/3-script/voicescript.yaml" "${vars.work_dir}/4-audio/docs.json" "${vars.voice_profile}"
+
+  - id: generate
+    description: "Invoke voice-gen generator plugin to generate audio"
+    onEnter:
+      - kind: shell
+        options:
+          command: >-
+            set -e;
+            extra="";
+            if [ -n "${vars.plugins_path}" ]; then extra="--plugins-path ${vars.plugins_path}"; fi;
+            kk executor run voice-gen --in "${vars.work_dir}/4-audio/docs.json" --out "${vars.work_dir}/4-audio/content.json" $extra
+
+  - id: duration-check
+    description: "Validate generated audio duration against target budget"
+
+  - id: done
+    description: "Terminal — Solo podcast VoiceScript and audio generated successfully"
+  - id: failed
+    description: "Terminal — Solo podcast workflow failed or rejected"
+
+transitions:
+  - from: prepare
+    to: understand
+    description: "Prepare completed -> begin briefing analysis"
+    guard:
+      kind: always
+
+  - from: understand
+    to: outline-write
+    description: "Briefing completed -> generate outline options"
+    guard:
+      kind: always
+
+  - from: outline-write
+    to: outline-select
+    description: "Outline not pre-selected -> pause for operator selection"
+    guard:
+      kind: shell
+      options:
+        command: 'test -z "${vars.outline}"'
+
+  - from: outline-write
+    to: outline-commit
+    description: "Outline pre-selected -> skip interactive selection"
+    guard:
+      kind: shell
+      options:
+        command: 'test -n "${vars.outline}"'
+
+  - from: outline-select
+    to: outline-commit
+    description: "Outline selected -> commit approved outline"
+    guard:
+      kind: always
+
+  - from: outline-commit
+    to: script-write
+    description: "Approved outline committed -> write VoiceScript"
+    guard:
+      kind: always
+
+  - from: script-write
+    to: script-validate
+    description: "VoiceScript written -> validate structure and caps"
+    guard:
+      kind: always
+
+  - from: script-validate
+    to: wrap-docs
+    description: "script_approved pre-set -> skip script review (CI/dry-run)"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.script_approved}" = "true"'
+  - from: script-validate
+    to: script-review
+    description: "VoiceScript validation passed -> pause for operator review"
+    guard:
+      kind: always
+
+  - from: script-review
+    to: wrap-docs
+    description: "VoiceScript approved -> wrap into Doc[] for generation"
+    guard:
+      kind: shell
+      options:
+        command: '{ test -z "${vars.__hitlAnswer}" || test "${vars.__hitlAnswer}" = "yes"; }'
+
+  - from: script-review
+    to: script-revise
+    description: "VoiceScript rejected with revision budget remaining -> collect feedback"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.__hitlAnswer}" = "no" && { run_id="${vars.__runId}"; if [ -z "$run_id" ]; then run_id="solo"; fi; test "$(cat .spur/run/$run_id-solo-revise-count 2>/dev/null || echo 0)" -lt 3; }'
+
+  - from: script-review
+    to: failed
+    description: "VoiceScript rejected with revision budget exhausted -> fail"
+    guard:
+      kind: shell
+      options:
+        command: 'test "${vars.__hitlAnswer}" = "no" && { run_id="${vars.__runId}"; if [ -z "$run_id" ]; then run_id="solo"; fi; test "$(cat .spur/run/$run_id-solo-revise-count 2>/dev/null || echo 0)" -ge 3; }'
+
+  - from: script-revise
+    to: script-write
+    description: "Feedback collected -> rewrite VoiceScript"
+    guard:
+      kind: always
+
+  - from: wrap-docs
+    to: generate
+    description: "Doc[] wrapped -> invoke voice-gen"
+    guard:
+      kind: always
+
+  - from: generate
+    to: duration-check
+    description: "Voice generation finished -> verify duration"
+    guard:
+      kind: always
+
+  - from: duration-check
+    to: done
+    description: "Audio duration within [0.5x, 2.0x] band or missing content.json in dry-run -> complete"
+    guard:
+      kind: shell
+      options:
+        command: >-
+          test ! -f "${vars.work_dir}/4-audio/content.json" || {
+            dur=$(jq -r '.metadata.duration // empty' "${vars.work_dir}/4-audio/content.json" 2>/dev/null);
+            test -n "$dur" && target_s=$((${vars.target_duration_min} * 60)) && min_s=$(awk -v t="$target_s" 'BEGIN {print t * 0.5}') && max_s=$(awk -v t="$target_s" 'BEGIN {print t * 2.0}') && awk -v d="$dur" -v min="$min_s" -v max="$max_s" 'BEGIN { if (d >= min && d <= max) exit 0; else exit 1 }';
+          }
+
+  - from: duration-check
+    to: failed
+    description: "Audio duration missing or outside [0.5x, 2.0x] target range -> fail"
+    guard:
+      kind: shell
+      options:
+        command: >-
+          test -f "${vars.work_dir}/4-audio/content.json" && {
+            dur=$(jq -r '.metadata.duration // empty' "${vars.work_dir}/4-audio/content.json" 2>/dev/null);
+            if [ -z "$dur" ]; then
+              echo "duration-check failed: metadata.duration missing or not a number" >&2;
+              exit 0;
+            fi;
+            target_s=$((${vars.target_duration_min} * 60));
+            min_s=$(awk -v t="$target_s" 'BEGIN {print t * 0.5}');
+            max_s=$(awk -v t="$target_s" 'BEGIN {print t * 2.0}');
+            awk -v d="$dur" -v min="$min_s" -v max="$max_s" -v ts="$target_s" 'BEGIN { if (d < min || d > max) { printf "duration-check failed: duration %ss outside 0.5x–2x of %ss\n", d, ts > "/dev/stderr"; exit 0 } else exit 1 }';
+          }

package/plugins/kk/workflows/validate-voicescript.ts

@@ -0,0 +1,226 @@
+#!/usr/bin/env bun
+/**
+ * Runtime VoiceScript checker for kk-solo-podcast.
+ *
+ * Copied with the workflow YAML into $KK_WORKFLOWS_DIR (default
+ * ~/.config/kk/workflows). Node/Bun builtins only — no @gobing-ai/* and no
+ * relative imports into generations/voice-gen (those paths do not exist next
+ * to the runtime copy).
+ *
+ * SYNC: plugins/generations/voice-gen/src/voicescript.ts (validateVoiceScript
+ * + engine/language enums + text/instruct/chunk/crossfade caps). Keep error
+ * substrings stable — apps/cli/tests/validate-voicescript.test.ts matches them.
+ */
+import { readFileSync } from 'node:fs';
+import { parseArgs } from 'node:util';
+
+const VOICEBOX_TEXT_MAX = 50_000;
+const VOICEBOX_INSTRUCT_MAX = 500;
+const VOICEBOX_CHUNK_CHARS_MIN = 100;
+const VOICEBOX_CHUNK_CHARS_MAX = 5_000;
+const VOICEBOX_CROSSFADE_MS_MIN = 0;
+const VOICEBOX_CROSSFADE_MS_MAX = 500;
+
+const VOICEBOX_ENGINES = [
+    'qwen',
+    'qwen_custom_voice',
+    'luxtts',
+    'chatterbox',
+    'chatterbox_turbo',
+    'tada',
+    'kokoro',
+] as const;
+
+const VOICEBOX_LANGUAGES = [
+    'zh',
+    'en',
+    'ja',
+    'ko',
+    'de',
+    'fr',
+    'ru',
+    'pt',
+    'es',
+    'it',
+    'he',
+    'ar',
+    'da',
+    'el',
+    'fi',
+    'hi',
+    'ms',
+    'nl',
+    'no',
+    'pl',
+    'sv',
+    'sw',
+    'tr',
+] as const;
+
+const ENGINE_SET = new Set<string>(VOICEBOX_ENGINES);
+const LANGUAGE_SET = new Set<string>(VOICEBOX_LANGUAGES);
+
+interface VoiceSpeaker {
+    profile: string;
+    engine?: string;
+    language?: string;
+    instruct?: string;
+}
+
+interface VoiceSegment {
+    speaker?: string;
+    profile?: string;
+    text: string;
+    instruct?: string;
+    engine?: string;
+    language?: string;
+    gap_ms?: number;
+    max_chunk_chars?: number;
+    crossfade_ms?: number;
+}
+
+interface VoiceScript {
+    default_engine?: string;
+    language?: string;
+    speakers?: Record<string, VoiceSpeaker>;
+    segments: VoiceSegment[];
+    max_chunk_chars?: number;
+    crossfade_ms?: number;
+}
+
+function assertEngine(value: string | undefined, label: string): void {
+    if (value !== undefined && !ENGINE_SET.has(value)) {
+        throw new Error(`${label} engine must be one of ${VOICEBOX_ENGINES.join('|')} (got "${value}")`);
+    }
+}
+
+function assertLanguage(value: string | undefined, label: string): void {
+    if (value !== undefined && !LANGUAGE_SET.has(value)) {
+        throw new Error(`${label} language must be a Voicebox language code (got "${value}")`);
+    }
+}
+
+function assertChunk(value: number | undefined): void {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isInteger(value) || value < VOICEBOX_CHUNK_CHARS_MIN || value > VOICEBOX_CHUNK_CHARS_MAX) {
+        throw new Error(`max_chunk_chars must be between ${VOICEBOX_CHUNK_CHARS_MIN} and ${VOICEBOX_CHUNK_CHARS_MAX}`);
+    }
+}
+
+function assertCrossfade(value: number | undefined): void {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isInteger(value) || value < VOICEBOX_CROSSFADE_MS_MIN || value > VOICEBOX_CROSSFADE_MS_MAX) {
+        throw new Error(`crossfade_ms must be between ${VOICEBOX_CROSSFADE_MS_MIN} and ${VOICEBOX_CROSSFADE_MS_MAX}`);
+    }
+}
+
+function validateVoiceScript(script: VoiceScript): void {
+    if (!script || typeof script !== 'object') {
+        throw new Error('VoiceScript must be an object');
+    }
+    if (!Array.isArray(script.segments) || script.segments.length === 0) {
+        throw new Error('VoiceScript must have a non-empty segments array');
+    }
+    assertChunk(script.max_chunk_chars);
+    assertCrossfade(script.crossfade_ms);
+    assertEngine(script.default_engine, 'VoiceScript default_engine');
+    assertLanguage(script.language, 'VoiceScript');
+
+    if (script.speakers) {
+        for (const [name, speaker] of Object.entries(script.speakers)) {
+            if (!speaker || typeof speaker !== 'object') {
+                throw new Error(`Speaker "${name}" definition must be an object`);
+            }
+            if (!speaker.profile || typeof speaker.profile !== 'string') {
+                throw new Error(`Speaker "${name}" must have a profile specified`);
+            }
+            if (typeof speaker.instruct === 'string' && speaker.instruct.length > VOICEBOX_INSTRUCT_MAX) {
+                throw new Error(`Speaker "${name}" instruct exceeds 500 characters (${speaker.instruct.length} chars)`);
+            }
+            assertEngine(speaker.engine, `Speaker "${name}"`);
+            assertLanguage(speaker.language, `Speaker "${name}"`);
+        }
+    }
+
+    for (let idx = 0; idx < script.segments.length; idx++) {
+        const segment = script.segments[idx];
+        if (!segment || typeof segment !== 'object') {
+            throw new Error(`Segment at index ${idx} must be an object`);
+        }
+        if (typeof segment.text !== 'string' || segment.text.length === 0) {
+            throw new Error(`Segment at index ${idx} text must not be empty`);
+        }
+        if (segment.text.length > VOICEBOX_TEXT_MAX) {
+            throw new Error(
+                `Segment text exceeds the 50,000-character Voicebox /generate cap (${segment.text.length} chars)`,
+            );
+        }
+        if (typeof segment.instruct === 'string' && segment.instruct.length > VOICEBOX_INSTRUCT_MAX) {
+            throw new Error(`Segment instruct exceeds 500 characters (${segment.instruct.length} chars)`);
+        }
+        if (segment.speaker && (!script.speakers || !(segment.speaker in script.speakers))) {
+            throw new Error(`Unknown speaker: "${segment.speaker}"`);
+        }
+        assertChunk(segment.max_chunk_chars);
+        assertCrossfade(segment.crossfade_ms);
+        if (segment.gap_ms !== undefined && (typeof segment.gap_ms !== 'number' || segment.gap_ms < 0)) {
+            throw new Error('gap_ms must be non-negative');
+        }
+        assertEngine(segment.engine, `Segment at index ${idx}`);
+        assertLanguage(segment.language, `Segment at index ${idx}`);
+    }
+}
+
+function main(): void {
+    const { values } = parseArgs({
+        args: process.argv.slice(2),
+        options: { in: { type: 'string' } },
+        strict: false,
+    });
+
+    const inPath = values.in;
+    if (!inPath) {
+        console.error('missing required --in <path>');
+        process.exit(1);
+    }
+
+    let raw: string;
+    try {
+        raw = readFileSync(inPath, 'utf-8');
+    } catch (err) {
+        console.error(`unreadable input file: ${inPath} (${err instanceof Error ? err.message : String(err)})`);
+        process.exit(1);
+    }
+
+    const trimmed = raw.trim();
+    if (trimmed === '') {
+        console.error(`input file is empty: ${inPath}`);
+        process.exit(1);
+    }
+
+    let parsed: unknown;
+    try {
+        parsed = trimmed.startsWith('{') ? JSON.parse(trimmed) : Bun.YAML.parse(trimmed);
+    } catch (err) {
+        console.error(`failed to parse VoiceScript: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        console.error('VoiceScript root must be an object');
+        process.exit(1);
+    }
+
+    try {
+        validateVoiceScript(parsed as VoiceScript);
+    } catch (err) {
+        console.error(`VoiceScript validation failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+
+main();

package/plugins/publishings/emdash-pub/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "@gobing-ai/emdash-pub",
+    "type": "module",
+    "private": true,
+    "scripts": {
+        "typecheck": "tsc --noEmit"
+    },
+    "dependencies": {
+        "@gobing-ai/kk-core": "workspace:*",
+        "@gobing-ai/publish-harness": "workspace:*",
+        "@gobing-ai/ts-runtime": "catalog:",
+        "@gobing-ai/ts-utils": "catalog:"
+    },
+    "devDependencies": {
+        "@types/bun": "1.3.14"
+    }
+}

package/plugins/publishings/emdash-pub/plugin.json

@@ -0,0 +1,7 @@
+{
+    "name": "emdash-pub",
+    "kind": "publish",
+    "entry": "./src/index.ts",
+    "version": "1.0.0",
+    "description": "Publish plugin for EmDash CMS creating posts via the REST token transport"
+}