dsh-plugin-local-infer 0.1.3 → 0.1.4

package/packages/orchestrator/lib/route.js

@@ -0,0 +1,159 @@
+/**
+ * The Orchestrator settings routes the Web card talks to: GET
+ * /local-infer/orchestrator answers { prompt, defaultPrompt, saved } (the
+ * effective prompt, the shipped prompt.md default, and whether the effective
+ * prompt is a saved value), and POST /local-infer/orchestrator/save persists
+ * { prompt } through the config setter (an empty string clears the saved
+ * override back to the default) and answers with the same payload. The routes
+ * are held by an effect, so they go when the component does.
+ *
+ * The HTTP plumbing is a minimal local mirror of the ui package's defineRoute
+ * template (method guard 405, bounded body 413, JSON answer). The ui package
+ * does export its template, but this package deliberately keeps no dependency
+ * on ui: importing ui's route module would load its whole route graph (the
+ * service, providers, and core packages) into a component that ships disabled
+ * and must stay loadable headless, so the shared shape is copied rather than
+ * imported, and the two copies change together by hand. The stream helpers
+ * the ui template carries are dropped; these two routes only ever answer with
+ * one JSON body.
+ * @module dsh-plugin-local-infer/orchestrator/route
+ */
+import { defaultOrchestratorPrompt, getOrchestratorPrompt, hasSavedOrchestratorPrompt, setOrchestratorPrompt, } from './config.js';
+/**
+ * RouteError is a route failure that carries its own HTTP status, so a
+ * handler can answer a validation rejection with its own code instead of the
+ * spec's failStatus.
+ */
+class RouteError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = 'RouteError';
+        this.status = status;
+    }
+}
+/**
+ * The request body size cap the save route enforces: a prompt is a few
+ * kilobytes at most, so a body past 64 KiB is a client bug, not a prompt.
+ * Deliberately mirrors the cap in packages/ui/src/route.ts (ui is not a
+ * dependency here): one malformed client misbehaves the same on every
+ * /local-infer route, so edit the two together.
+ */
+const MAX_BODY_BYTES = 64 * 1024;
+/**
+ * readJsonBody collects a bounded JSON request body: chunks up to the cap,
+ * then parses. A body past the cap destroys the request and throws a 413
+ * RouteError carrying the route's own message, so the answer names the route
+ * that rejected the body.
+ */
+async function readJsonBody(req, tooLargeMessage) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        total += chunk.length;
+        if (total > MAX_BODY_BYTES) {
+            req.destroy();
+            throw new RouteError(413, tooLargeMessage);
+        }
+        chunks.push(chunk);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+/** Writes one JSON answer (status head plus body) on the response. */
+function writeJson(res, status, body) {
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+/**
+ * defineRoute is the local template both route specs build on: it guards the
+ * method (405), reads the bounded body (413, POST only), and maps the
+ * handler's answer to a status: a RouteError carries its own status, any
+ * other failure answers with the spec's failStatus.
+ */
+function defineRoute(spec) {
+    return {
+        name: spec.name,
+        kind: 'exact',
+        path: spec.path,
+        handler: async (req, res) => {
+            if (req.method !== spec.method) {
+                res.writeHead(405).end();
+                return;
+            }
+            try {
+                const body = spec.method === 'POST' ? await readJsonBody(req, spec.tooLargeMessage) : {};
+                await spec.run({ url: new URL(req.url, 'http://localhost'), body }, (status, answer) => writeJson(res, status, answer));
+            }
+            catch (error) {
+                if (error instanceof RouteError) {
+                    writeJson(res, error.status, { error: error.message });
+                    return;
+                }
+                writeJson(res, spec.failStatus, { error: String(error?.message ?? error) });
+            }
+        },
+    };
+}
+function orchestratorPayload() {
+    return {
+        prompt: getOrchestratorPrompt(),
+        defaultPrompt: defaultOrchestratorPrompt(),
+        saved: hasSavedOrchestratorPrompt(),
+    };
+}
+/**
+ * orchestratorGetRoute builds the GET /local-infer/orchestrator route. The
+ * client treats any non-404 answer as proof the route is mounted, so the
+ * payload answers 200 even before anything is saved.
+ */
+function orchestratorGetRoute() {
+    return defineRoute({
+        name: 'local-infer-orchestrator',
+        path: '/local-infer/orchestrator',
+        method: 'GET',
+        failStatus: 500,
+        run: async (_input, json) => {
+            json(200, orchestratorPayload());
+        },
+    });
+}
+/**
+ * orchestratorSaveRoute builds the POST /local-infer/orchestrator/save route:
+ * a string prompt persists through setOrchestratorPrompt (an empty string
+ * clears the saved override back to the default) and the answer carries the
+ * GET payload shape so the card re-renders from one response.
+ */
+function orchestratorSaveRoute() {
+    return defineRoute({
+        name: 'local-infer-orchestrator-save',
+        path: '/local-infer/orchestrator/save',
+        method: 'POST',
+        failStatus: 400,
+        tooLargeMessage: 'orchestrator prompt payload too large',
+        run: async ({ body }, json) => {
+            if (typeof body.prompt !== 'string') {
+                throw new RouteError(400, 'prompt must be a string');
+            }
+            setOrchestratorPrompt(body.prompt);
+            json(200, orchestratorPayload());
+        },
+    });
+}
+/**
+ * registerOrchestratorRoutes registers the GET and save routes on the web
+ * server and holds them by an effect, so a component switch off removes them
+ * before the next switch on re-registers. The scoped context carries the
+ * webServer.
+ */
+export function registerOrchestratorRoutes(scope) {
+    const routes = [orchestratorGetRoute(), orchestratorSaveRoute()];
+    scope.effect(() => {
+        const disposers = routes.map((route) => scope.webServer.register(route));
+        return () => {
+            for (const dispose of disposers) {
+                dispose();
+            }
+        };
+    }, 'local-infer-orchestrator: settings routes');
+}
+//# sourceMappingURL=route.js.map

package/packages/orchestrator/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Orchestrator",
+    "description": "Edit the Orchestrator Prompt the component injects into the system prompt while it is enabled."
+  }
+}

package/packages/orchestrator/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "dsh-plugin-local-infer-orchestrator",
+  "version": "0.1.4",
+  "description": "Orchestrator component for the dsh local-inference plugin: an editable Orchestrator Prompt persisted under ~/.dsh/local-infer, defaulted from the shipped prompt.md, injected into the system prompt while the component is enabled",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "local-inference",
+    "orchestrator",
+    "system-prompt"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.d.ts",
+    "prompt.md",
+    "locale/en.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.6-alpha.2"
+  }
+}

package/packages/orchestrator/prompt.md

@@ -0,0 +1,87 @@
+# Role & Core Objective
+You are an advanced software engineering orchestration agent.
+Your goal is to systematically plan, execute, and finalize user requests using micro-tasks and subagents.
+Always adhere strictly to the following execution sequence.
+
+---
+
+## Step 1: Initialization & Planning
+1. **Gather Context**: Analyze the user request.
+2. **Initialize Plan**: Execute the `todo_write` tool. Include an initial strategy containing a Phase Plan, Task Breakdown, and a Questionnaire step.
+   Do not include individual tasks at this time.
+3. **Generate Plan File**: Create a Markdown file named `PLAN-{{1OR2WORD-SLUG}}.md` in the root directory containing:
+    - A short description of the objective at the very top.
+    - Verification guidelines (Do not duplicate any rules found in `AGENTS.md`).
+    - A sequential list of open questions for the user.
+    - An ordered list of micro-tasks, group logically by Phase.
+      Each task must represent the smallest possible unit of work with a concrete, verifiable "Definition of Done".
+4. **Review Plan File**: Remove any duplicative context so that each statement
+   the single source of truth. Remove reasoning notes about task ordering,
+   replacing with a clear Markdown list of task dependencies.
+
+## Step 2: Refactoring Tasks Injection
+Where appropriate, insert specialized tasks starting with `Refactor:` into your task sequence.
+These tasks must contain the exact following instruction block,
+with the `{{N}}` count template replaced by the number of Tasks in the Phase:
+```text
+Review the files touched by the previous {{N}} commits and identify the following code risks:
+ - **Multiple Sources of Truth**: Same calculations done in multiple places.
+ - **Duplicate Code**: Nearly-identical code in multiple methods.
+ - **Bloaters**: Too many things done in a single method or class.
+ - **Data Clumps**: Single variables that travel in a group for multiple methods.
+ - **Shotgun Edits**: Commits with singular changes that touch multiple files.
+ - **Feature Envy**: Method where over 50% of the code manipulates a different class.
+ - **Magic Numbers**: Literals without context in method bodies.
+Then address and resolve each risk.
+```
+
+## Step 3: Architecture-Dependent Architecture Selection
+Count the total number of sequential tasks generated. Execute branch **A** or **B** based on the count:
+
+### Branch A: High-Complexity Architecture (5 or More Tasks)
+1. **Deconstruct Plan**: Extract each task body out of the main index file.
+2. **Create Task Files**: Save each task into its own file using this naming convention: `docs/PLAN-{{1OR2WORD-SLUG}}-TASK-###-{{SHORT-DESC-SLUG}}.md`.
+3. **Update Main Index**: Ensure `PLAN-{{1OR2WORD-SLUG}}.md` becomes a slim index where tasks are grouped logically by section and linked using exact Markdown checklist syntax:
+   ` - [ ] [TASK-###-{{SHORT-DESC-SLUG}}](docs/PLAN-{{1OR2WORD-SLUG}}-TASK-###-{{SHORT-DESC-SLUG}}.md)`
+4. **Set Session Goals**: Use the `create_goal` tool to register all session goals.
+
+### Branch B: Low-Complexity Architecture (Less Than 5 Tasks)
+1. **Deconstruct Tasks**: Break down each task into a series of todos.
+   In Step 4, when writing each task to the global todo list, include the
+   series of todos for each task as an individual todo between tasks.
+
+## Step 4: Questionnaire & Baseline Commit
+1. **Append To-Dos**: Use the `todo_write` tool to insert your tasks directly into the global todo list.
+2. **Add Finalizer To-Do**: Append a final `Finalize` item to the end of that list.
+3. **Interview User**: For every open question identified in Step 1, invoke the `ask_user_question` tool individually.
+   Provide at least one recommended answer and leave a spot open for the user to answer with their own input.
+4. **Persist Answers**: As answers arrive, write them directly into `PLAN-{{1OR2WORD-SLUG}}.md` (or the specific task file if using Branch A).
+5. **Close Questionnaire**: Mark the Questionnaire task as complete.
+6. **Commit Blueprint**: If on Branch A (High-Complexity), commit the created `PLAN` file (and accompanying `docs/` task files if applicable) to repository version control.
+
+## Step 5: Subagent Execution Loop
+Loop through the tasks sequentially. For **each** incomplete task:
+1. **Launch Subagent**: Trigger the `subagent` tool with this exact prompt,
+   replacing the PLAN filename template:
+   ```text
+   1. Complete the next Task in @PLAN-{{1OR2WORD-SLUG}}.md .
+   2. Use the `todo_write` tool to plan your work.
+   3. Check ('[x]') the task in the file when done, then commit the completed work.
+   4. List any discovered pre-existing issues for the parent agent to review.
+   5. Then you are finished; resolve remaining todos and end the turn.
+   ```
+2. **Confirm Subagent** Trigger the `list_agents` tool to confirm the subagent is running, then end turn.
+3. **Resume and Evaluate Subagent Output**: The subagent will resume with a `notify` in a new turn.
+   If the subagent discovers pre-existing codebase issues, insert new tasks immediately after the current task in the appropriate execution order.
+4. **Sync State**: Invoke the `todo_write` tool to check off progress.
+5. **Repeat**: Proceed to the next task until all items in the plan are checked `[x]`.
+
+## Step 6: Finalization & Handoff
+1. **Cleanup Artifacts**: Delete all generated `PLAN-{{1OR2WORD-SLUG}}.md` and `docs/PLAN-{{1OR2WORD-SLUG}}-TASK*` files.
+   Remove all memory and file references, restoring the repo development to a stateless condition.
+2. **Commit Cleanup**: Commit these deletions to repository version control.
+3. **Wrap up tasks**: Sync and close out any lingering task tracking states using the appropriate tool.
+4. **Present Results**: Invoke the `present` tool to officially deliver the completed work to the user.
+5. **Complete**: End the turn.
+
+---

package/packages/providers/lib/acquire.d.ts

@@ -8,7 +8,8 @@
  * local changes aborts, because a rebase would eat the user's work.
  * @module dsh-plugin-local-infer/providers/acquire
  */
-import type { LifecycleHost } from '../../core/lib/index.js';
+import type { DeployOptions, EnginePlatformConfig, LaunchProgress, LifecycleHost } from '../../core/lib/index.js';
+import type { EngineOsProfile } from './engines/engineOs.ts';
 /**
  * EngineSource is the per-engine acquisition data: the upstream git repo the
  * clone step uses when no fork is provided, the branch the fetch/rebase step
@@ -20,6 +21,7 @@ export interface EngineSource {
     repo: string;
     branch: string;
     buildSteps: readonly string[];
+    windowsBuildSteps?: readonly string[];
 }
 /**
  * The remote name a user-provided fork is added under, so the checkout's own
@@ -32,9 +34,35 @@ export declare const FORK_REMOTE = "dsh-fork";
  * the same cmake shape as NInfer; Hyper-Qwen is the compose-driven vLLM
  * engine, so it carries no local build steps (the compose up pulls the
  * image); Strata builds through its own setup.sh (the README's
- * Build-from-source route), which the source-build mode runs in the checkout.
+ * Build-from-source route), which the source-build mode runs in the checkout;
+ * Basalt builds through its own CMake route (the Ninja/MSVC variant on
+ * Windows). The build steps are read from the per-engine OS profiles, so a
+ * build command has one home (the OS-specific files under engines/).
  */
 export declare const ENGINE_SOURCES: Record<string, EngineSource>;
+/**
+ * engineOsProfile reads the registered build profile for an engine id on an OS,
+ * or undefined when none is registered. A host OS with no dedicated profile
+ * (a Windows host for an engine that carries no Windows route) reads the
+ * shared Linux profile.
+ */
+export declare function engineOsProfile(engineId: string, os?: 'linux' | 'windows' | 'macos'): EngineOsProfile | undefined;
+/**
+ * engineBuildDir reads the directory, relative to the checkout, where an
+ * engine's build leaves its binary on an OS, so the binary symlink step reads
+ * the right tree. A Windows host reads the engine's Windows build tree (the
+ * vcpkg route for NInfer writes into build-windows\apps\Release); every other
+ * host reads the shared Linux build directory. An engine that installs its
+ * binary to the path (Strata) carries no build directory, so it reads as
+ * `build`, the shared default.
+ */
+export declare function engineBuildDir(engineId: string, os?: 'linux' | 'windows' | 'macos'): string;
+/**
+ * engineBinary reads the engine binary name on an OS (the .exe on Windows), so
+ * the adapters and the symlink step share one source. An engine with no local
+ * binary (the compose engines) reads as undefined.
+ */
+export declare function engineBinary(engineId: string, os?: 'linux' | 'windows' | 'macos'): string | undefined;
 /**
  * AcquireLog receives one line (or chunk) of Get output as it lands, so the
  * route can stream it to the card's Logs section.
@@ -50,44 +78,63 @@ export interface EngineStepResult {
     aborted?: boolean;
     detail?: string;
 }
+/**
+ * SyncStepResult is the sync step's EngineStepResult plus the path it took:
+ * `cloned` true means a fresh clone ran (no prior checkout), so a failure on
+ * that path leaves no current version to launch; an absent `cloned` means the
+ * checkout was present and the rebase, fetch, or dirty path ran, so a failure
+ * there leaves a launchable current version. The Get step reads the flag to
+ * decide a sync failure's fatality instead of re-probing the checkout.
+ */
+export interface SyncStepResult extends EngineStepResult {
+    cloned?: boolean;
+}
 /**
  * engineSource reads the registered acquisition data for an engine id, or
  * undefined when none is registered.
  */
 export declare function engineSource(engineId: string): EngineSource | undefined;
 /**
- * engineBuildSteps reads the build steps an engine runs in its checkout, so
- * the adapter's deploy step and the Get build step share one list.
+ * engineBuildSteps reads the build steps an engine runs in its checkout for an
+ * OS, so the adapter's deploy step and the Get build step share one list. The
+ * steps come from the engine's OS profile: a Windows host reads the engine's
+ * Windows profile (the vcpkg route for NInfer), and a host OS with no
+ * dedicated profile reads the shared Linux profile.
  */
-export declare function engineBuildSteps(engineId: string): readonly string[];
+export declare function engineBuildSteps(engineId: string, os?: 'linux' | 'windows' | 'macos'): readonly string[];
 /**
  * syncEngineRepo brings the engine checkout to the listed source. A missing
  * checkout is a fresh clone of the fork (or the engine's upstream repo when
  * no fork is provided). An existing checkout with local changes aborts, so
  * the user's work is never rebased away; a clean checkout fetches the listed
  * fork (added as the named fork remote when provided, origin when not) and
- * rebases onto its branch. Every command echoes into log as it runs.
+ * rebases onto its branch. Every command echoes into log as it runs. The
+ * result's `cloned` flag names the path taken: set on a fresh clone (the
+ * checkout was absent), absent on the present-checkout path, so a caller
+ * prices a failure's fatality from the flag instead of re-probing the
+ * checkout.
  */
 export declare function syncEngineRepo(host: LifecycleHost, request: {
     engineId: string;
     directory: string;
     fork?: string;
-}, log: AcquireLog): Promise<EngineStepResult>;
+}, log: AcquireLog): Promise<SyncStepResult>;
 /**
  * SyncRebuildRequest names the checkout the conditional rebuild prices: the
- * engine, its directory, the optional fork remote, the engine binary the
- * symlink step links when a rebuild leaves it out of the path, and the
- * Play/Run trust gate that decides whether that symlink runs (on) or is
- * written to the logs (off).
+ * engine, its directory, the optional fork remote, and the Play/Run trust gate
+ * that decides whether the binary symlink (added when a rebuild leaves the
+ * binary out of the path) runs (on) or is written to the logs (off). The
+ * symlink step reads the bare binary name from the engine profile, so the
+ * request carries no binary of its own.
  */
 export interface SyncRebuildRequest {
     engineId: string;
     directory: string;
     fork?: string;
-    binary?: string;
     allowRunDeps?: boolean;
     buildCommands?: string;
     onBuildStart?: () => void;
+    os?: 'linux' | 'windows' | 'macos';
 }
 /**
  * SyncRebuildResult reports the conditional rebuild: whether it passed,
@@ -117,11 +164,42 @@ export interface SyncRebuildResult {
  * added (run when the trust gate is on, written to the logs when it is off).
  */
 export declare function syncAndRebuildEngine(host: LifecycleHost, request: SyncRebuildRequest, log: AcquireLog): Promise<SyncRebuildResult>;
+/**
+ * EngineDeploySync reports the deploy step's git sync (the shared
+ * syncAndRebuildEngine): whether it passed, a detail for a failure, and the
+ * captured build output the deploy step threads to the card's Logs section
+ * (a "Building..." separator leads a rebuild's output, the same line the
+ * card writes when the build step event lands).
+ */
+export interface EngineDeploySync {
+    ok: boolean;
+    detail?: string;
+    buildLogs: string;
+}
+/**
+ * syncEngineForDeploy runs the deploy step's git sync (the shared
+ * syncAndRebuildEngine) with the option shape every adapter's deploy step
+ * assembles: the platform entry's fork and build-command override, the
+ * Play/Run trust gate, the plan's host OS (the Windows vcpkg route when the
+ * user carries no build-command override), and the progress sink the card's
+ * button reads (the git sync reports "Downloading...", the build step
+ * reports "Building..." the moment it starts). The captured build output is
+ * returned as buildLogs, so a caller threads it to the card's Logs section
+ * without re-running the steps.
+ */
+export declare function syncEngineForDeploy(host: LifecycleHost, request: {
+    engineId: string;
+    directory: string;
+    platform?: EnginePlatformConfig;
+    options?: DeployOptions;
+    os?: 'linux' | 'windows' | 'macos';
+    onProgress?: LaunchProgress;
+}): Promise<EngineDeploySync>;
 /**
  * buildEngineRepo runs the engine's build steps in the checkout, streaming
  * each step's output through log. An engine with no build steps (the compose
  * engines) passes through with a note; a failing step stops the build with
  * the step's detail.
  */
-export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog, buildCommands?: string): Promise<EngineStepResult>;
-//# sourceMappingURL=acquire.d.ts.map
+export declare function buildEngineRepo(host: LifecycleHost, engineId: string, directory: string, log: AcquireLog, buildCommands?: string, os?: 'linux' | 'windows' | 'macos'): Promise<EngineStepResult>;
+//# sourceMappingURL=acquire.d.ts.map