@evandu/super-pi 0.1.130 → 0.1.132

package/dist/server/command-handler.js

@@ -13,6 +13,7 @@ export class CommandHandler {
     catalogService;
     rootDir;
     providerService;
+    scheduledTaskService;
     /**
      * The built-in terminal service.
      *
@@ -28,7 +29,15 @@ export class CommandHandler {
      * Optional because the command handler is constructed by tests that do not care about providers,
      * and a missing service has to say so rather than take the whole handler down.
      */
-    providerService) {
+    providerService, 
+    /**
+     * The scheduled tasks, and the clock behind them.
+     *
+     * Optional because the handler is constructed by tests that have no clock to give it, and a missing
+     * service has to say so rather than take the whole handler down - the same rule `providerService`
+     * follows.
+     */
+    scheduledTaskService) {
         this.workspaceService = workspaceService;
         this.conversationService = conversationService;
         this.runService = runService;
@@ -36,6 +45,7 @@ export class CommandHandler {
         this.catalogService = catalogService;
         this.rootDir = rootDir;
         this.providerService = providerService;
+        this.scheduledTaskService = scheduledTaskService;
         this.terminalService = terminalService;
     }
     /**
@@ -295,6 +305,44 @@ export class CommandHandler {
             this.runService.stopWorkflow(command.workflowId);
             return;
         }
+        // THE SCHEDULED TASKS, five commands over one list.
+        //
+        // They are all here rather than in a service of their own because they are all one verb applied to
+        // one collection: the service owns the schedule and the clock, and this is the routing table that
+        // says which of its methods a command reaches.
+        if (command.type === "scheduledTask.create") {
+            await this.requireScheduledTasks().create({
+                name: command.name,
+                prompt: command.prompt,
+                schedule: command.schedule,
+                workspaceId: command.workspaceId,
+                model: command.model,
+                agentId: command.agentId,
+            }, "user");
+            return;
+        }
+        if (command.type === "scheduledTask.update") {
+            await this.requireScheduledTasks().update(command.id, {
+                name: command.name,
+                prompt: command.prompt,
+                schedule: command.schedule,
+                model: command.model,
+                agentId: command.agentId,
+            });
+            return;
+        }
+        if (command.type === "scheduledTask.delete") {
+            await this.requireScheduledTasks().remove(command.id);
+            return;
+        }
+        if (command.type === "scheduledTask.trigger") {
+            await this.requireScheduledTasks().trigger(command.id);
+            return;
+        }
+        if (command.type === "scheduledTask.toggle") {
+            await this.requireScheduledTasks().setEnabled(command.id, command.enabled);
+            return;
+        }
         if (command.type === "extension.ui.answer") {
             const answer = command.cancelled
                 ? { cancelled: true }
@@ -396,4 +444,15 @@ export class CommandHandler {
         }
         throw new Error(`未知的命令类型：${JSON.stringify(command.type ?? null)}`);
     }
+    /**
+     * The scheduled-task service, or a refusal.
+     *
+     * A refusal in the client's own words rather than a crash: the panel that sent the command shows
+     * the message, and a handler that threw a TypeError would show nothing but a failed operation.
+     */
+    requireScheduledTasks() {
+        if (!this.scheduledTaskService)
+            throw new Error("定时任务功能在这个实例上没有启用。");
+        return this.scheduledTaskService;
+    }
 }

package/dist/server/documents.d.ts

@@ -0,0 +1,152 @@
+/**
+ * THE DOCUMENT PARSING LAYER.
+ *
+ * It turns the files a person actually has - PDFs, Word documents, spreadsheets - into text, and it
+ * turns text back into those files. Everything else in Super Pi - the knowledge base, the agent's
+ * document tool - goes through here, so the same file reads the same way in both places.
+ *
+ * WHY IT LIVES ON THE SERVER AND NOT IN A PI EXTENSION. A Pi extension runs inside Pi's process, and
+ * Pi's process resolves `node_modules` against PI's install, not against Super Pi's. The parsing
+ * libraries are Super Pi's dependencies, so an extension could not load them: the code would work in
+ * the dev checkout and fail in every installed layout, which is the exact failure mode
+ * `scripts/installed-layout.test.mjs` exists to catch. The server is also the only layer that holds
+ * both the workspace's absolute paths and the capability tokens, so the path guard and the
+ * credential check live in the same place as the parsing.
+ *
+ * WHY EVERY LIBRARY IS OPTIONAL. The knowledge base's vector layer is optional for the same reason:
+ * a missing package must degrade the FEATURE, not break the PANEL. A user who did not install
+ * pdfjs-dist should still be able to run Super Pi and read their Markdown; they should get a clear
+ * sentence about which package to install when they try to read a PDF.
+ */
+/**
+ * The document formats this layer understands, by file extension.
+ *
+ * `ppt` is READ-ONLY: the legacy binary format has no pure-JS writer, and generating a real
+ * PowerPoint 97 file means reimplementing a 1997 binary format. Reading it is a record walk; writing
+ * it is refused with a pointer to `.pptx`.
+ */
+export type DocumentFormat = "pdf" | "docx" | "xlsx" | "pptx" | "ppt";
+/**
+ * The tools the agent sees.
+ *
+ * Duplicated as literals in `agents/super-pi-documents/index.ts`, the way `KNOWLEDGE_TOOL_NAME` is:
+ * the extension runs in Pi's process and cannot import from the server, and a name that exists in
+ * only one of the two places is a name one of them will get wrong.
+ */
+export declare const DOCUMENT_READ_TOOL_NAME = "document_read";
+export declare const DOCUMENT_WRITE_TOOL_NAME = "document_write";
+/** What a caller needs to know about a document after it has been read. */
+export type ExtractResult = {
+    /** The extracted text. Empty only when the source genuinely had no text layer. */
+    text: string;
+    /** The format the text came from. */
+    format: DocumentFormat;
+    /** How many pages the document had, when the format has pages. */
+    pages?: number;
+    /**
+     * What was lost in the conversion, stated rather than hidden.
+     *
+     * WHY THIS IS A FIELD AND NOT A LOG LINE. A Word document's tables become pipe-separated lines and
+     * its images become nothing at all. A caller that knows the extraction was lossy can say so to the
+     * person; a caller that does not will present a flattened table as if it were the document.
+     */
+    warnings: string[];
+};
+/** The failure of a document that could not be read, in a form a person can act on. */
+export declare class DocumentError extends Error {
+    readonly code: DocumentErrorCode;
+    constructor(code: DocumentErrorCode, message: string);
+}
+/**
+ * WHY THE CODES EXIST. "Read failed" is not actionable, and the ways a document fails are
+ * genuinely different from one another: a dependency is missing (install something), a PDF has no
+ * text layer (it is a scan - use a different route), a PDF is encrypted (it needs a password), and
+ * the file is simply broken (nothing to do about it). Each of those needs a different sentence, and
+ * a person who is told "read failed" learns nothing.
+ */
+export type DocumentErrorCode = "missing_dependency" | "missing_asset" | "no_text_layer" | "encrypted" | "corrupt" | "unsupported" | "empty";
+/**
+ * Whether an extension names a document this layer can read.
+ *
+ * The name is checked BEFORE the bytes are sniffed, because the caller needs to know whether to
+ * attempt a parse at all - and because a `.pdf` that is really a text file is a different situation
+ * from a file with no extension that happens to be a PDF.
+ */
+export declare function isDocumentFormat(extension: string): boolean;
+/** The format an extension names, or null when it names none. */
+export declare function documentFormatOf(extension: string): DocumentFormat | null;
+/** The extension a format is written with. */
+export declare function extensionForFormat(format: DocumentFormat): string;
+/**
+ * Reads a document's text.
+ *
+ * The file is read here rather than handed in as a buffer because the parsers differ in what they
+ * want: pdfjs wants a path or a typed array, mammoth wants a buffer, exceljs wants a stream or a
+ * buffer. Reading once here keeps that difference from leaking into the callers.
+ */
+export declare function extractText(path: string, format: DocumentFormat): Promise<ExtractResult>;
+/**
+ * Reads a document's text from bytes already in hand.
+ *
+ * Split out from `extractText` so the parsers can be exercised without touching the filesystem, and
+ * so a caller that already has the bytes (an upload, an API request) does not write them to a
+ * temporary file to read them back.
+ */
+export declare function extractTextFromBytes(bytes: Buffer, format: DocumentFormat): Promise<ExtractResult>;
+/**
+ * WHAT A DOCUMENT IS TO BE WRITTEN FROM.
+ *
+ * The content is Markdown for prose documents and CSV for spreadsheets, chosen by the format rather
+ * than by the caller: a spreadsheet built from Markdown is a table with the wrong shape, and the
+ * caller should not have to know that.
+ */
+export type DocumentSpec = {
+    format: DocumentFormat;
+    /** The content. Markdown for `docx`, `pdf` and `pptx`, CSV for `xlsx`. */
+    content: string;
+    /** The document's title, used for the Word heading and the PDF title line. */
+    title?: string;
+};
+/**
+ * Builds a document's bytes.
+ *
+ * The output is a REAL document - it opens in Word, Excel and a PDF reader - not a renamed text
+ * file. The structure is simple on purpose: headings, paragraphs, lists and tables for Word;
+ * sheets of cells for Excel; lines of text for a PDF.
+ */
+export declare function buildDocument(spec: DocumentSpec): Promise<{
+    bytes: Buffer;
+    format: DocumentFormat;
+}>;
+/**
+ * The blocks a Markdown document is made of.
+ *
+ * A full Markdown parser is not needed here, and pulling one in would mean deciding what to do with
+ * the constructs it supports that a Word document has no place for. The subset below is the one a
+ * person actually uses when they ask for "a Word version of this".
+ */
+type Block = {
+    kind: "heading";
+    level: number;
+    text: string;
+} | {
+    kind: "paragraph";
+    text: string;
+} | {
+    kind: "list";
+    items: string[];
+} | {
+    kind: "table";
+    header: string[];
+    rows: string[][];
+} | {
+    kind: "code";
+    text: string;
+};
+/** Splits Markdown into the blocks a document is built from. Exported for the tests to exercise directly. */
+export declare function parseMarkdownBlocks(markdown: string): Block[];
+/**
+ * The format a file's extension names, for the callers that hold a path rather than a format.
+ */
+export declare function formatOfPath(path: string): DocumentFormat | null;
+export {};