@eatosin/dshify-plugin 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Owadokun Tosin Tobi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# @eatosin/dshify-plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+DeepSeek Harness (DSH) plugin for [dshify](https://github.com/Eatosin/dshify). It ports an OpenCode repository to a DSH surface from inside a session.
+
+## Install
+
+In DSH, open the plugin installation page and enter the package name:
+
+```text
+@eatosin/dshify-plugin
+```
+
+Compatibility: DSH `0.2.2-rc.1` and later. The plugin requires Node.js 22.12 or later. It depends on `@eatosin/dshify`, which contains the migration engine and the offline core.
+
+## What it adds
+
+The plugin adds one model-facing tool and one human command.
+
+| Name | Purpose |
+|---|---|
+| `migrate_harness` tool | Run `scan`, `plan`, `apply`, or `check` on a repository. |
+| `/migrate` command | The same actions from the composer. Default action is `plan`. |
+
+The tool input:
+
+| Field | Type | Default | Notes |
+|---|---|---|---|
+| `action` | `scan` \| `plan` \| `apply` \| `check` | required | `apply` writes files. |
+| `path` | string | `.` | Repository path. Relative paths use the session working directory. |
+| `dest` | string | `.dsh` | Destination tree inside the repository. |
+| `presets` | boolean | `false` | Also emit the `.dsh/harness/` preset bundle. |
+| `force` | boolean | `false` | Replace human-edited artifacts during `apply`. |
+
+`apply` writes only inside `dest` and the lockfile. It never deletes user files. If a file is not owned by dshify, `apply` reports a conflict.
+
+## Command
+
+```text
+/migrate plan                 # show the conversion plan
+/migrate apply . --presets    # write the surface and the preset bundle
+/migrate check                # verify files, lockfile and DSH discovery
+```
+
+## Security
+
+- The migration engine is offline. `scan`, `plan`, and `check` never make network calls.
+- `apply` writes files. Use a test branch first.
+- No secret value from the source repository enters the tool output.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# Host-only bundle: one row activates the dshify tool and the /migrate command.
+- insert:
+    - id: dshify
+      name: '@eatosin/dshify-plugin'

package/icon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="dshify migration">
+  <rect x="4" y="10" width="56" height="44" rx="7" fill="#111827"/>
+  <path d="M14 24l9 8-9 8" fill="none" stroke="#34d399" stroke-width="4" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M28 40h22" stroke="#e5e7eb" stroke-width="4" stroke-linecap="round"/>
+  <circle cx="52" cy="18" r="6" fill="#34d399"/>
+</svg>

package/index.d.ts

@@ -0,0 +1,5 @@
+/** dshify migration plugin for DeepSeek Harness. */
+export declare const name: 'dshify';
+export declare const inject: readonly string[];
+/** Register the `migrate_harness` tool and the `/migrate` command. */
+export declare function apply(ctx: unknown): void;

package/index.js

@@ -0,0 +1,360 @@
+/**
+ * dshify migration plugin for DeepSeek Harness.
+ *
+ * Host half: registers the model-facing `migrate_harness` tool and the
+ * human-facing `/migrate` command. All work happens in @eatosin/dshify, the
+ * offline CLI engine. The plugin adds no network access.
+ *
+ * Loader contract: `apply(ctx)` registers resources through `ctx.effect`.
+ * The tool definition is plain JSON Schema data; no harness package import is
+ * needed, so the bundle has no peer dependencies.
+ */
+import { readFile, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import {
+  DEFAULT_SCAN_LIMITS,
+  VERSION,
+  applyRepo,
+  checkRepo,
+  planRepo,
+  scanRepo,
+} from '@eatosin/dshify';
+
+export const name = 'dshify';
+export const inject = ['tools'];
+
+const ACTIONS = ['scan', 'plan', 'apply', 'check'];
+const LOCKFILE = '.dshify.lock.json';
+
+const TOOL_DESCRIPTION =
+  'Port an OpenCode repository to a DeepSeek Harness (DSH) surface. ' +
+  'Actions: "scan" lists the source skills, commands, personas and MCP servers (read-only); ' +
+  '"plan" shows the DSH artifacts, findings and losses (read-only); ' +
+  '"apply" writes .dsh/ and .dshify.lock.json (writes files; use a test branch); ' +
+  '"check" verifies the files, the lockfile and DSH discovery (read-only). ' +
+  'apply never deletes user files and refuses to overwrite files it does not own.';
+
+const SUMMARY_SCHEMA = {
+  type: 'object',
+  additionalProperties: true,
+  description: 'Counts for the completed action.',
+};
+
+const OUTPUT_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    action: { type: 'string', enum: ACTIONS, description: 'Action that ran.' },
+    ok: { type: 'boolean', description: 'True when the action found no blocking problem.' },
+    root: { type: 'string', description: 'Absolute repository root.' },
+    exitCode: { type: 'integer', description: '0, 3 (drift or conflict) or 4 (verification failed).' },
+    summary: SUMMARY_SCHEMA,
+    findings: { type: 'array', items: { type: 'object', additionalProperties: true } },
+    artifacts: { type: 'array', items: { type: 'object', additionalProperties: true } },
+    verification: { type: 'object', additionalProperties: true },
+  },
+  required: ['action', 'ok', 'root'],
+};
+
+const TOOL = {
+  name: 'migrate_harness',
+  description: TOOL_DESCRIPTION,
+  parameters: {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+      action: {
+        type: 'string',
+        enum: ACTIONS,
+        description: 'scan, plan, apply or check.',
+      },
+      path: {
+        type: 'string',
+        description: 'Repository path. A relative path resolves from the working directory. Default: ".".',
+      },
+      dest: {
+        type: 'string',
+        description: 'Destination tree inside the repository. Default: ".dsh".',
+      },
+      presets: {
+        type: 'boolean',
+        description: 'Also emit the .dsh/harness/ preset bundle (persona and MCP rows).',
+      },
+      force: {
+        type: 'boolean',
+        description: 'Replace human-edited artifacts during apply. Use with care.',
+      },
+    },
+    required: ['action'],
+  },
+  output: {
+    schema: OUTPUT_SCHEMA,
+    render(_args, value) {
+      return [{ type: 'text', text: formatResult(value) }];
+    },
+  },
+  presentCall(args) {
+    const action = typeof args?.action === 'string' ? args.action : 'migration';
+    return { card: 'generic', title: `dshify ${action}`, kind: 'other', rawInput: args };
+  },
+  async execute(rawArgs) {
+    const input = validateInput(rawArgs);
+    return await runAction(input);
+  },
+};
+
+const COMMAND = {
+  name: 'migrate',
+  description: 'Port an OpenCode repository to DSH (scan, plan, apply, check).',
+  handler: async (invocation) => {
+    try {
+      const input = parseCommand(invocation.rawInput);
+      return { kind: 'success', text: formatResult(await runAction(input)) };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return { kind: 'error', text: message };
+    }
+  },
+};
+
+/**
+ * Register the tool and, when the profile has the command service, /migrate.
+ * @param {object} ctx - Cordis context.
+ */
+export function apply(ctx) {
+  ctx.effect(() => ctx.tools.register(TOOL));
+
+  const commands = typeof ctx.get === 'function' ? ctx.get('commands') : undefined;
+  if (commands !== undefined && typeof commands.register === 'function') {
+    ctx.effect(() => commands.register(COMMAND));
+  }
+}
+
+/**
+ * Validate model input. The registry enforces the JSON Schema; this adds the
+ * path and enum guarantees the action bodies rely on.
+ * @param {unknown} value
+ */
+function validateInput(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('migrate_harness: arguments must be an object');
+  }
+  const input = /** @type {Record<string, unknown>} */ (value);
+  const action = input['action'];
+  if (typeof action !== 'string' || !ACTIONS.includes(action)) {
+    throw new Error(`migrate_harness: action must be one of ${ACTIONS.join(', ')}`);
+  }
+  const readString = (key) => {
+    const field = input[key];
+    if (field === undefined) return undefined;
+    if (typeof field !== 'string' || field.length === 0) {
+      throw new Error(`migrate_harness: ${key} must be a non-empty string`);
+    }
+    return field;
+  };
+  const readBoolean = (key) => {
+    const field = input[key];
+    if (field === undefined) return false;
+    if (typeof field !== 'boolean') throw new Error(`migrate_harness: ${key} must be a boolean`);
+    return field;
+  };
+  for (const key of Object.keys(input)) {
+    if (!['action', 'path', 'dest', 'presets', 'force'].includes(key)) {
+      throw new Error(`migrate_harness: unknown argument ${key}`);
+    }
+  }
+  return {
+    action,
+    path: readString('path'),
+    dest: readString('dest') ?? '.dsh',
+    presets: readBoolean('presets'),
+    force: readBoolean('force'),
+  };
+}
+
+/**
+ * Resolve the scan root and its repository root without importing CLI internals.
+ * @param {string} target
+ */
+async function resolveRoots(target) {
+  const requested = path.resolve(process.cwd(), target);
+  let scanRoot;
+  try {
+    scanRoot = await realpath(requested);
+  } catch {
+    throw new Error(`path does not exist: ${target}`);
+  }
+  const info = await stat(scanRoot);
+  if (!info.isDirectory()) throw new Error(`path is not a directory: ${target}`);
+
+  let current = scanRoot;
+  for (;;) {
+    try {
+      await stat(path.join(current, '.git'));
+      return { scanRoot, repoRoot: current };
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return { scanRoot, repoRoot: scanRoot };
+      current = parent;
+    }
+  }
+}
+
+async function readResource(absolute) {
+  return new Uint8Array(await readFile(absolute));
+}
+
+/**
+ * Run one action through the dshify engine.
+ * @param {{action: string, path?: string, dest: string, presets: boolean, force: boolean}} input
+ */
+async function runAction(input) {
+  const { scanRoot, repoRoot } = await resolveRoots(input.path ?? '.');
+  const ir = await scanRepo({ root: scanRoot, extraRoots: [], limits: DEFAULT_SCAN_LIMITS });
+  const base = {
+    repoRoot,
+    dest: input.dest,
+    presets: input.presets,
+    strategy: 'copy',
+    version: VERSION,
+    readResource,
+  };
+  const findings = [...ir.warnings];
+
+  if (input.action === 'scan') {
+    return {
+      action: 'scan',
+      ok: true,
+      root: repoRoot,
+      summary: {
+        skills: ir.skills.length,
+        commands: ir.commands.length,
+        personas: ir.personas.length,
+        mcpServers: ir.mcpServers.length,
+        findings: findings.length,
+      },
+      findings,
+    };
+  }
+
+  if (input.action === 'plan') {
+    const planned = await planRepo(ir, base);
+    return {
+      action: 'plan',
+      ok: planned.conflicts.length === 0,
+      root: repoRoot,
+      summary: {
+        artifacts: planned.artifacts.length,
+        losses: planned.losses.length,
+        conflicts: planned.conflicts.length,
+      },
+      findings: [...findings, ...planned.losses],
+      artifacts: planned.artifacts.map((artifact) => ({
+        path: artifact.path,
+        kind: artifact.kind,
+        capability: artifact.capability,
+      })),
+    };
+  }
+
+  if (input.action === 'apply') {
+    const applied = await applyRepo(ir, { ...base, lockfilePath: LOCKFILE, force: input.force });
+    const counts = {};
+    for (const result of applied.results) {
+      counts[result.status] = (counts[result.status] ?? 0) + 1;
+    }
+    return {
+      action: 'apply',
+      ok: applied.ok,
+      root: repoRoot,
+      exitCode: applied.ok ? 0 : 3,
+      summary: { ...counts, conflicts: applied.conflicts.length, lockfile: applied.lockfilePath },
+      findings: [...findings, ...applied.findings],
+      artifacts: applied.results.map((result) => ({
+        path: result.path,
+        kind: result.kind,
+        capability: result.capability,
+        status: result.status,
+      })),
+    };
+  }
+
+  const checked = await checkRepo(ir, { ...base, lockfilePath: LOCKFILE, limits: DEFAULT_SCAN_LIMITS });
+  return {
+    action: 'check',
+    ok: checked.ok,
+    root: repoRoot,
+    exitCode: checked.exitCode,
+    summary: {
+      planned: checked.planned.artifacts.length,
+      visible: checked.verification.visible.length,
+      skipped: checked.verification.skipped.length,
+      findings: checked.findings.length,
+    },
+    findings: [...findings, ...checked.findings],
+    verification: {
+      roots: checked.verification.roots,
+      visible: checked.verification.visible.map((skill) => skill.path),
+      skipped: checked.verification.skipped,
+      complete: checked.verification.complete,
+    },
+    artifacts: checked.results.map((result) => ({
+      path: result.path,
+      kind: result.kind,
+      capability: result.capability,
+      status: result.status,
+    })),
+  };
+}
+
+/**
+ * Parse `/migrate [action] [path] [--presets] [--force]`.
+ * @param {string} rawInput
+ */
+function parseCommand(rawInput) {
+  const tokens = rawInput.trim().split(/\s+/).filter(Boolean);
+  let action = 'plan';
+  if (tokens.length > 0 && ACTIONS.includes(tokens[0])) action = tokens.shift();
+  let presets = false;
+  let force = false;
+  const positional = [];
+  for (const token of tokens) {
+    if (token === '--presets') presets = true;
+    else if (token === '--force') force = true;
+    else positional.push(token);
+  }
+  const target = positional[0];
+  return { action, path: target, dest: '.dsh', presets, force };
+}
+
+/**
+ * Model-facing text for one result.
+ * @param {object} value
+ */
+function formatResult(value) {
+  const lines = [`dshify ${value.action}: ${value.ok ? 'ok' : 'needs attention'}`];
+  if (value.exitCode !== undefined) lines.push(`exit code: ${value.exitCode}`);
+  lines.push(`root: ${value.root}`);
+  if (value.summary !== undefined) {
+    const summary = Object.entries(value.summary)
+      .map(([key, count]) => `${key}=${count}`)
+      .join(' ');
+    if (summary !== '') lines.push(`summary: ${summary}`);
+  }
+  if (Array.isArray(value.findings) && value.findings.length > 0) {
+    lines.push('findings:');
+    for (const finding of value.findings) {
+      const where = finding.path === undefined ? '' : ` ${finding.path}`;
+      lines.push(`- ${finding.code ?? finding.code} (${finding.severity ?? 'info'})${where}`);
+    }
+  }
+  if (Array.isArray(value.artifacts) && value.artifacts.length > 0) {
+    lines.push('artifacts:');
+    for (const artifact of value.artifacts.slice(0, 50)) {
+      const status = artifact.status === undefined ? '' : ` [${artifact.status}]`;
+      lines.push(`- ${artifact.path} (${artifact.capability})${status}`);
+    }
+  }
+  lines.push('', JSON.stringify(value, null, 2));
+  return lines.join('\n');
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "dshify migration",
+    "description": "Port an OpenCode repository to DeepSeek Harness. Scan, plan, apply and check with owned writes and discovery verification."
+  }
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@eatosin/dshify-plugin",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Port an OpenCode repository to DeepSeek Harness from inside DSH: scan, plan, apply and check, with owned writes and discovery verification.",
+  "icon": "icon.svg",
+  "author": "Owadokun Tosin Tobi",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.12.0",
+    "dsh": ">=0.2.2-rc.1"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "cordis",
+    "plugin",
+    "migration",
+    "opencode"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Eatosin/dshify.git",
+    "directory": "plugin"
+  },
+  "homepage": "https://github.com/Eatosin/dshify#readme",
+  "bugs": {
+    "url": "https://github.com/Eatosin/dshify/issues"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.2.2-rc.1+": "compatible"
+      }
+    }
+  },
+  "dependencies": {
+    "@eatosin/dshify": "^0.1.2"
+  },
+  "types": "index.d.ts"
+}