poe-code 3.0.258 → 3.0.259-beta.1

package/packages/agent-traces/dist/types.d.ts

@@ -0,0 +1,84 @@
+export type AgentTraceSource = "claude" | "codex";
+export interface AgentTraceFileSystem {
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string, options?: {
+        encoding?: BufferEncoding;
+    }): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    stat(path: string): Promise<{
+        isFile(): boolean;
+        isDirectory(): boolean;
+        mtime?: Date;
+    }>;
+}
+export interface SqliteTraceDatabase {
+    all(sql: string, params: unknown[]): unknown[] | Promise<unknown[]>;
+    close(): void | Promise<void>;
+}
+export type SqliteTraceDatabaseFactory = (path: string) => Promise<SqliteTraceDatabase>;
+export interface TraceDiscoverOptions {
+    cwd?: string;
+    homeDir: string;
+    since?: Date;
+    allWorkspaces?: boolean;
+    fs: AgentTraceFileSystem;
+    sqlite?: SqliteTraceDatabaseFactory;
+}
+export type TraceReadOptions = Pick<TraceDiscoverOptions, "fs">;
+export interface TraceReference {
+    source: AgentTraceSource;
+    id: string;
+    path?: string;
+    cwd?: string;
+    updatedAt?: Date;
+    title?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface NormalizedTrace {
+    source: AgentTraceSource;
+    id: string;
+    path?: string;
+    cwd?: string;
+    title?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    turns: NormalizedTraceTurn[];
+}
+export interface NormalizedTraceTurn {
+    id?: string;
+    role: "human" | "assistant" | "tool" | "system";
+    text: string;
+    timestamp?: Date;
+    sourceKind?: string;
+}
+export interface HumanPromptRecord {
+    traceId: string;
+    source: AgentTraceSource;
+    cwd?: string;
+    title?: string;
+    timestamp?: string;
+    text: string;
+}
+export interface CollectHumanPromptsOptions {
+    sources?: AgentTraceSource[];
+    cwd?: string;
+    homeDir?: string;
+    since?: Date;
+    limit?: number;
+    allWorkspaces?: boolean;
+    fs?: AgentTraceFileSystem;
+    sqlite?: SqliteTraceDatabaseFactory;
+}
+export interface CollectHumanPromptsResult {
+    records: HumanPromptRecord[];
+    traceCount: number;
+}
+export interface TraceReader {
+    id: AgentTraceSource;
+    defaultRoots(homeDir: string): string[];
+    discover(options: TraceDiscoverOptions): Promise<TraceReference[]>;
+    read(reference: TraceReference, options: TraceReadOptions): Promise<NormalizedTrace>;
+}

package/packages/agent-traces/dist/types.js

@@ -0,0 +1 @@
+export {};

package/packages/package-lint/dist/model.js

@@ -190,7 +190,11 @@ export async function loadWorkspace(fs, rootDir) {
     for (const p of packages)
         byDir.set(p.dir, p);
     const { shippedDirs, binTargets } = deriveShipped(root);
-    const sourceImports = await scanSourceImports(fs, rootDir, packages.map((p) => p.dir));
+    const workspaceNames = new Set(packages.map((p) => p.name));
+    const sourceImports = await scanSourceImports(fs, rootDir, packages.map((pkg) => ({
+        dir: pkg.dir,
+        workspaceNames: new Set([...workspaceNames].filter((name) => name !== pkg.name))
+    })));
     return {
         root,
         packages,

package/packages/package-lint/dist/source-imports.d.ts

@@ -17,10 +17,20 @@ export interface ImportRef {
 }
 /** Imports found in each workspace package, keyed by the package dir (posix). */
 export type SourceImportView = Map<string, ImportRef[]>;
+interface RawImport {
+    specifier: string;
+    typeOnly: boolean;
+}
+export declare function extractRelevantImports(text: string, fileName: string): RawImport[];
+export declare function mayContainRelevantImport(source: string, workspaceNames: ReadonlySet<string>): boolean;
 /**
  * Parse the real import graph of every workspace package's `src`, using the
  * TypeScript compiler's own parser (the engine typescript-eslint runs on). The
  * result feeds the import-driven rules — what code actually imports, not what
  * package.json declares.
  */
-export declare function scanSourceImports(fs: LintFs, rootDir: string, packageDirs: string[]): Promise<SourceImportView>;
+export declare function scanSourceImports(fs: LintFs, rootDir: string, packages: Array<{
+    dir: string;
+    workspaceNames: ReadonlySet<string>;
+}>): Promise<SourceImportView>;
+export {};

package/packages/package-lint/dist/source-imports.js

@@ -14,7 +14,7 @@ function isTestFile(relFile) {
     const segments = relFile.split("/");
     return segments.some((s) => s === "test" || s === "tests" || s === "__tests__");
 }
-function extractImports(text, fileName) {
+function extractImportsFromAst(text, fileName) {
     const sourceFile = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, false, fileName.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
     const out = [];
     for (const statement of sourceFile.statements) {
@@ -61,6 +61,15 @@ function extractImports(text, fileName) {
     visit(sourceFile);
     return out;
 }
+export function extractRelevantImports(text, fileName) {
+    if (text.includes("import type") || text.includes("export type") || text.includes("{ type ")) {
+        return extractImportsFromAst(text, fileName);
+    }
+    return ts.preProcessFile(text, true, true).importedFiles.map(({ fileName: specifier }) => ({
+        specifier,
+        typeOnly: false
+    }));
+}
 async function listSourceFiles(fs, dir) {
     let entries;
     try {
@@ -82,6 +91,20 @@ async function listSourceFiles(fs, dir) {
     }
     return files;
 }
+export function mayContainRelevantImport(source, workspaceNames) {
+    const imports = ts.preProcessFile(source, true, true).importedFiles;
+    for (const { fileName } of imports) {
+        if (fileName.startsWith("../")) {
+            return true;
+        }
+        for (const packageName of workspaceNames) {
+            if (fileName === packageName || fileName.startsWith(`${packageName}/`)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 function classify(raw, rootDir, packageDir, absFile, relFile) {
     const base = {
         file: relFile,
@@ -116,9 +139,9 @@ function classify(raw, rootDir, packageDir, absFile, relFile) {
  * result feeds the import-driven rules — what code actually imports, not what
  * package.json declares.
  */
-export async function scanSourceImports(fs, rootDir, packageDirs) {
+export async function scanSourceImports(fs, rootDir, packages) {
     const view = new Map();
-    await Promise.all(packageDirs.map(async (packageDir) => {
+    await Promise.all(packages.map(async ({ dir: packageDir, workspaceNames }) => {
         const srcDir = path.join(rootDir, packageDir, "src");
         const files = await listSourceFiles(fs, srcDir);
         const refs = [];
@@ -130,8 +153,11 @@ export async function scanSourceImports(fs, rootDir, packageDirs) {
             catch {
                 continue;
             }
+            if (!mayContainRelevantImport(text, workspaceNames)) {
+                continue;
+            }
             const relFile = toPosix(path.relative(rootDir, absFile));
-            for (const raw of extractImports(text, absFile)) {
+            for (const raw of extractRelevantImports(text, absFile)) {
                 refs.push(classify(raw, rootDir, packageDir, absFile, relFile));
             }
         }

package/packages/tiny-stdio-mcp-test-server/dist/cli.js

@@ -2,6 +2,8 @@
 
 // packages/tiny-stdio-mcp-test-server/src/cli.ts
 import { Command } from "commander";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { access } from "node:fs/promises";
 
 // packages/tiny-stdio-mcp-test-server/package.json
 var package_default = {
@@ -1223,6 +1225,7 @@ function defineSchema(definition) {
 }
 
 // packages/tiny-stdio-mcp-test-server/src/index.ts
+import { appendFileSync } from "node:fs";
 var SERVER_NAME = "tiny-stdio-mcp-test-server";
 var SERVER_VERSION = package_default.version;
 var caesarCipherSchema = defineSchema({
@@ -1262,11 +1265,19 @@ function createEncryptServer() {
     "Encrypts text using the Caesar cipher",
     caesarCipherSchema,
     ({ text, shift }) => {
+      recordToolCall("caesar_cipher_encrypt");
       const actualShift = shift ?? 3;
       return caesarEncrypt(text, actualShift);
     }
   );
 }
+function recordToolCall(name) {
+  const filePath = process.env.TOOLCRAFT_TEST_TOOL_CALL_FILE;
+  if (filePath !== void 0) {
+    appendFileSync(filePath, `${name}
+`);
+  }
+}
 function createWordOfTheDayServer() {
   return createServer({
     name: SERVER_NAME,
@@ -1285,6 +1296,15 @@ function createWordOfTheDayServer() {
 var program = new Command();
 program.name("tiny-stdio-mcp-test-server").description("Test MCP server with example tools for integration testing").version(package_default.version);
 program.command("serve").description("Start an MCP server on stdin/stdout").argument("<tool>", "Tool to serve (encrypt, word-of-the-day)").action(async (tool) => {
+  recordProcessStart();
+  const startupDelayMs = Number(process.env.TOOLCRAFT_TEST_STARTUP_DELAY_MS ?? "0");
+  if (startupDelayMs > 0) {
+    await new Promise((resolve) => setTimeout(resolve, startupDelayMs));
+  }
+  const startupGateFile = process.env.TOOLCRAFT_TEST_STARTUP_GATE_FILE;
+  if (startupGateFile !== void 0) {
+    await waitForFile(startupGateFile);
+  }
   const servers = /* @__PURE__ */ Object.create(null);
   Object.assign(servers, {
     encrypt: () => createEncryptServer().listen(),
@@ -1299,3 +1319,24 @@ program.command("serve").description("Start an MCP server on stdin/stdout").argu
   await start();
 });
 program.parse();
+function recordProcessStart() {
+  const countFile = process.env.TOOLCRAFT_TEST_SPAWN_COUNT_FILE;
+  if (countFile !== void 0) {
+    const previousCount = existsSync(countFile) ? Number.parseInt(readFileSync(countFile, "utf8").trim() || "0", 10) : 0;
+    writeFileSync(countFile, String(previousCount + 1));
+  }
+  const pidFile = process.env.TOOLCRAFT_TEST_WRAPPER_PID_FILE;
+  if (pidFile !== void 0) {
+    writeFileSync(pidFile, String(process.pid));
+  }
+}
+async function waitForFile(filePath) {
+  while (true) {
+    try {
+      await access(filePath);
+      return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+  }
+}

package/packages/tiny-stdio-mcp-test-server/dist/index.js

@@ -1,4 +1,5 @@
 import { createServer, defineSchema } from "tiny-stdio-mcp-server";
+import { appendFileSync } from "node:fs";
 import packageJson from "../package.json" with { type: "json" };
 const SERVER_NAME = "tiny-stdio-mcp-test-server";
 const SERVER_VERSION = packageJson.version;
@@ -34,10 +35,17 @@ export function createEncryptServer() {
         name: SERVER_NAME,
         version: SERVER_VERSION,
     }).tool("caesar_cipher_encrypt", "Encrypts text using the Caesar cipher", caesarCipherSchema, ({ text, shift }) => {
+        recordToolCall("caesar_cipher_encrypt");
         const actualShift = shift ?? 3;
         return caesarEncrypt(text, actualShift);
     });
 }
+function recordToolCall(name) {
+    const filePath = process.env.TOOLCRAFT_TEST_TOOL_CALL_FILE;
+    if (filePath !== undefined) {
+        appendFileSync(filePath, `${name}\n`);
+    }
+}
 export function createWordOfTheDayServer() {
     return createServer({
         name: SERVER_NAME,