@docyrus/docyrus 0.0.39 → 0.0.41

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@docyrus/docyrus",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "private": false,
   "description": "Docyrus API CLI",
   "main": "./main.js",
   "bin": {
     "docyrus": "main.js"
   },
+  "scripts": {
+    "postinstall": "node ./resources/officecli/install.mjs"
+  },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "@hono/node-server": "^1.14.1",

package/resources/officecli/install.mjs

@@ -0,0 +1,111 @@
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SKIP_ENV_NAME = "DOCYRUS_SKIP_OFFICECLI_POSTINSTALL";
+const scriptDirectoryPath = dirname(fileURLToPath(import.meta.url));
+const packageRootPath = resolve(scriptDirectoryPath, "..", "..");
+const manifestPath = join(scriptDirectoryPath, "manifest.json");
+const bundledRootPath = join(scriptDirectoryPath, "bundled");
+
+function resolveOfficeCliAssetName() {
+  switch (process.platform) {
+    case "darwin":
+      if (process.arch === "arm64") {
+        return "officecli-mac-arm64";
+      }
+      if (process.arch === "x64") {
+        return "officecli-mac-x64";
+      }
+      break;
+    case "linux": {
+      const alpineSuffix = existsSync("/etc/alpine-release") ? "-alpine" : "";
+      if (process.arch === "arm64") {
+        return `officecli-linux${alpineSuffix}-arm64`;
+      }
+      if (process.arch === "x64") {
+        return `officecli-linux${alpineSuffix}-x64`;
+      }
+      break;
+    }
+    case "win32":
+      if (process.arch === "arm64") {
+        return "officecli-win-arm64.exe";
+      }
+      if (process.arch === "x64") {
+        return "officecli-win-x64.exe";
+      }
+      break;
+    default:
+      break;
+  }
+
+  throw new Error(`Unsupported OfficeCLI platform: ${process.platform}/${process.arch}`);
+}
+
+async function readManifest() {
+  const manifestRaw = await readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(manifestRaw);
+
+  if (!manifest || typeof manifest.version !== "string" || manifest.version.trim().length === 0) {
+    throw new Error("OfficeCLI manifest is missing a valid version.");
+  }
+
+  return {
+    version: manifest.version.trim(),
+  };
+}
+
+async function main() {
+  if (process.env[SKIP_ENV_NAME] === "1") {
+    return;
+  }
+
+  if (existsSync(join(packageRootPath, "project.json"))) {
+    return;
+  }
+
+  const { version } = await readManifest();
+  const assetName = resolveOfficeCliAssetName();
+  const targetPath = join(bundledRootPath, assetName);
+
+  if (existsSync(targetPath)) {
+    return;
+  }
+
+  await mkdir(bundledRootPath, {
+    recursive: true,
+    mode: 0o755,
+  });
+
+  const tempPath = `${targetPath}.download${process.platform === "win32" ? ".exe" : ""}`;
+
+  try {
+    const response = await fetch(`https://github.com/iOfficeAI/OfficeCLI/releases/download/v${version}/${assetName}`);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+
+    const binary = Buffer.from(await response.arrayBuffer());
+    await writeFile(tempPath, binary, {
+      mode: process.platform === "win32" ? 0o644 : 0o755,
+    });
+
+    if (process.platform !== "win32") {
+      await chmod(tempPath, 0o755);
+    }
+
+    await rename(tempPath, targetPath);
+  } catch (error) {
+    await rm(tempPath, {
+      force: true,
+    });
+
+    const reason = error instanceof Error ? error.message : "Unknown error";
+    process.stderr.write(`[docyrus] OfficeCLI postinstall download failed: ${reason}\n`);
+    process.exitCode = 0;
+  }
+}
+
+await main();

package/resources/officecli/manifest.json

@@ -0,0 +1,3 @@
+{
+  "version": "1.0.31"
+}

package/resources/pi-agent/extensions/plan.ts

@@ -28,6 +28,7 @@ const PLAN_ANCHOR_TYPE = "plan-anchor";
 const PLAN_CONFIG_FILE = ".pi/plan-policy.json";
 const PLAN_WIDGET_KEY = "plan-mode";
 const PLAN_BRANCH_LABEL = "plan";
+const ARCHITECT_PLAN_ARTIFACT_FILE_NAME = "PLAN.md";
 const ALLOWED_TODO_ACTIONS = new Set(["list", "list-all", "get"]);
 const ALL_THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh"] satisfies ThinkingLevel[]);
 
@@ -96,6 +97,12 @@ export interface IReadPlanPolicyResult {
 	error?: string;
 }
 
+interface IPlanningCliEnvironment {
+	executable: string;
+	entryPath: string;
+	scope: "local" | "global";
+}
+
 export type IParseResult<T> = { ok: true; value: T } | { ok: false; error: string };
 
 let currentPlanState: IPlanSessionState | undefined;
@@ -120,6 +127,41 @@ function expandUserPath(inputPath: string): string {
   return inputPath;
 }
 
+function readPlanningCliEnvironment(env: NodeJS.ProcessEnv = process.env): IPlanningCliEnvironment {
+  const executable = env.DOCYRUS_CLI_EXECUTABLE?.trim();
+  const entryPath = env.DOCYRUS_CLI_ENTRY?.trim();
+  const scope = env.DOCYRUS_CLI_SCOPE?.trim() as "local" | "global" | undefined;
+  if (!executable || !entryPath || (scope !== "local" && scope !== "global")) {
+    throw new Error("Missing Docyrus CLI runtime env. Expected DOCYRUS_CLI_EXECUTABLE, DOCYRUS_CLI_ENTRY, and DOCYRUS_CLI_SCOPE.");
+  }
+
+  return {
+    executable,
+    entryPath,
+    scope,
+  };
+}
+
+async function runProjectPlanCliJson<TValue>(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  args: string[],
+): Promise<TValue> {
+  const environment = readPlanningCliEnvironment();
+  const scopedArgs = environment.scope === "global" ? ["-g", ...args] : args;
+  const result = await pi.exec(environment.executable, [environment.entryPath, ...scopedArgs, "--json"], {
+    cwd: ctx.cwd,
+  });
+  const stdout = result.stdout?.toString().trim() || "";
+  const stderr = result.stderr?.toString().trim() || "";
+  const output = stdout || stderr;
+  if (result.code !== 0 || !output) {
+    throw new Error(output || `Command exited with code ${result.code ?? "unknown"}.`);
+  }
+
+  return JSON.parse(output) as TValue;
+}
+
 function resolveAgentRootPath(): string {
   const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
   return agentDir && agentDir.length > 0 ? expandUserPath(agentDir) : path.join(os.homedir(), ".pi", "agent");
@@ -635,6 +677,28 @@ async function writePlanArtifactFromEvent(event: AgentEndEvent, ctx: ExtensionCo
   }
 }
 
+async function writeArchitectArtifactFromEvent(event: AgentEndEvent, ctx: ExtensionContext): Promise<void> {
+  const state = getPlanState(ctx);
+  if (!state?.active || !state.artifactPath || state.mode !== "architect") {
+    return;
+  }
+
+  const text = extractLastAssistantText(event.messages ?? []);
+  if (!text || parseAskUserRequestFromText(text)) {
+    return;
+  }
+
+  try {
+    await fs.mkdir(state.artifactPath, { recursive: true });
+    await fs.writeFile(path.join(state.artifactPath, ARCHITECT_PLAN_ARTIFACT_FILE_NAME), `${text.trim()}\n`, "utf8");
+  } catch (error) {
+    if (ctx.hasUI) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`Failed to write architect plan artifact: ${message}`, "error");
+    }
+  }
+}
+
 export function shouldBlockTodoAction(action: string | undefined): boolean {
   return !!action && !ALLOWED_TODO_ACTIONS.has(action);
 }
@@ -973,6 +1037,36 @@ export async function endPlanningWorkflow(pi: ExtensionAPI, ctx: ExtensionComman
   setPlanWidget(ctx, undefined);
   await restoreSourceModel(pi, ctx, state);
 
+  if (state.artifactPath) {
+    try {
+      const syncResult = state.mode === "architect"
+        ? await runProjectPlanCliJson<{ updatedTaskIds?: string[] }>(pi, ctx, [
+          "project-plan",
+          "upsert-from-architect",
+          "--artifactDir",
+          state.artifactPath,
+          ...(state.task ? ["--brief", state.task] : []),
+        ])
+        : await runProjectPlanCliJson<{ updatedTaskIds?: string[] }>(pi, ctx, [
+          "project-plan",
+          "upsert-from-plan",
+          "--artifactPath",
+          state.artifactPath,
+          ...(state.task ? ["--task", state.task] : []),
+        ]);
+
+      if (ctx.hasUI) {
+        const updatedCount = Array.isArray(syncResult.updatedTaskIds) ? syncResult.updatedTaskIds.length : 0;
+        ctx.ui.notify(`Project plan synced from ${state.mode} artifact (${updatedCount} task update${updatedCount === 1 ? "" : "s"}).`, "info");
+      }
+    } catch (error) {
+      if (ctx.hasUI) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Project plan sync failed after ${state.mode}: ${message}`, "warning");
+      }
+    }
+  }
+
   if (ctx.hasUI) {
     const artifactSuffix = state.artifactPath ? ` Artifact: ${state.artifactPath}` : "";
     ctx.ui.notify(`Planning session ended.${artifactSuffix}`, "info");
@@ -1176,6 +1270,7 @@ export default function planExtension(pi: ExtensionAPI) {
     }
 
     await writePlanArtifactFromEvent(event, ctx);
+    await writeArchitectArtifactFromEvent(event, ctx);
   });
 
   pi.on("session_start", async(_event, ctx) => {