tsci-agent 0.1.0 → 0.1.1

package/README.md

@@ -38,6 +38,27 @@ tsci-agent do --prompt "Try this refactor" --dir ./somedir --sandbox
 
 `--sandbox` protects the original directory from ordinary writes by using a copy, but it is not a security boundary or container.
 
+## Library usage
+
+You can also run the agent from another Bun/TypeScript program and inspect the sandbox after the prompt completes:
+
+```ts
+import { runPromptInSandbox } from "tsci-agent/lib";
+
+await using result = await runPromptInSandbox("Review this tscircuit project", {
+  dir: "./somedir",
+  // Optional Pi SDK CLI-style args:
+  // piArgs: ["--model", "openai/gpt-4.1"],
+});
+
+console.log(result.output);
+console.log(await result.files.ls());
+console.log(await result.files.read("index.circuit.tsx"));
+console.log(result.sandboxDir);
+```
+
+`runPromptInSandbox` copies `dir` to a temporary workspace, runs the prompt there, and returns `output`, `sandboxDir`, `originalDir`, `sessionId`, and `files` helpers scoped to the sandbox. Use `await using` as shown, or call `await result.dispose()`, to remove the temporary sandbox when you are done reading it. Like CLI `--sandbox`, this is a temporary filesystem copy, not a security boundary.
+
 ## Build
 
 ```bash

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli.js

@@ -244812,7 +244812,7 @@ function applyExifOrientation(photon, image, originalBytes) {
 
 // node_modules/@silvia-odwyer/photon-node/photon_rs.js
 var require_photon_rs = __commonJS((exports, module3) => {
-  var __dirname = "/Users/seve/w/tsc/tsci-agent/node_modules/@silvia-odwyer/photon-node";
+  var __dirname = "/home/runner/work/tsci-agent/tsci-agent/node_modules/@silvia-odwyer/photon-node";
   var imports = {};
   imports["__wbindgen_placeholder__"] = exports;
   var wasm;
@@ -279831,11 +279831,13 @@ function renderEvent(event2) {
 // src/do-command.ts
 var exports_do_command = {};
 __export(exports_do_command, {
-  runDoCommand: () => runDoCommand
+  runDoCommand: () => runDoCommand,
+  runAgentPrompt: () => runAgentPrompt,
+  prepareWorkingDirectory: () => prepareWorkingDirectory
 });
 import { cp, mkdtemp, realpath as realpath3 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join37, resolve as resolve17 } from "path";
+import { join as join37, relative as relative9, resolve as resolve17 } from "path";
 function readValue(args, index2, option) {
   const value2 = args[index2 + 1];
   if (!value2 || value2.startsWith("--")) {
@@ -279888,32 +279890,33 @@ function parseDoCommand(args) {
   }
   return options3;
 }
-async function prepareWorkingDirectory(dir, sandbox) {
+async function prepareWorkingDirectory(dir, sandbox, report = false) {
   const sourceDir = await realpath3(resolve17(dir));
   if (!sandbox)
-    return sourceDir;
+    return { cwd: sourceDir, sourceDir };
   const sandboxRoot = await mkdtemp(join37(tmpdir6(), "tsci-agent-"));
   const sandboxDir = join37(sandboxRoot, "workspace");
   await cp(sourceDir, sandboxDir, {
     recursive: true,
-    filter: (path16) => !path16.includes("/.git/")
+    filter: (path16) => !relative9(sourceDir, path16).split(/[\\/]/).includes(".git")
   });
-  console.error(`[tsci-agent] sandbox copy: ${sourceDir} -> ${sandboxDir}`);
-  console.error("[tsci-agent] sandbox is a temporary filesystem copy, not a security boundary.");
-  return sandboxDir;
+  if (report) {
+    console.error(`[tsci-agent] sandbox copy: ${sourceDir} -> ${sandboxDir}`);
+    console.error("[tsci-agent] sandbox is a temporary filesystem copy, not a security boundary.");
+  }
+  return { cwd: sandboxDir, sourceDir, sandboxRoot };
 }
-async function runDoCommand(args) {
-  const options3 = parseDoCommand(args);
-  const prompt = options3.prompt;
-  if (!prompt)
-    throw new Error("`tsci-agent do` requires --prompt <text>.");
-  const cwd = await prepareWorkingDirectory(options3.dir, options3.sandbox);
+async function runAgentPrompt(options3) {
+  const { cwd } = await prepareWorkingDirectory(options3.dir, options3.sandbox ?? false, options3.report ?? false);
   const skillPath = await findTscircuitSkill();
-  const parsed = parseArgs(options3.piArgs);
-  reportDiagnostics2(parsed.diagnostics);
+  const parsed = parseArgs(options3.piArgs ?? []);
+  if (options3.report)
+    reportDiagnostics2(parsed.diagnostics);
   const fatalDiagnostics = parsed.diagnostics.filter((diagnostic) => diagnostic.type === "error");
-  if (fatalDiagnostics.length > 0)
-    process.exit(1);
+  if (fatalDiagnostics.length > 0) {
+    throw new Error(fatalDiagnostics.map((diagnostic) => diagnostic.message).join(`
+`));
+  }
   const agentDir = getAgentDir();
   const authStorage = createAuthStorage(parsed);
   const modelRegistry = ModelRegistry.create(authStorage);
@@ -279937,22 +279940,41 @@ async function runDoCommand(args) {
     model,
     ...createSessionOptionOverrides(parsed)
   });
-  if (modelFallbackMessage)
-    console.error(`[warning] ${modelFallbackMessage}`);
-  reportDiagnostics2(loader.getSkills().diagnostics);
-  for (const error54 of extensionsResult.errors) {
-    console.error(`[warning] extension ${error54.path}: ${error54.error}`);
+  if (options3.report) {
+    if (modelFallbackMessage)
+      console.error(`[warning] ${modelFallbackMessage}`);
+    reportDiagnostics2(loader.getSkills().diagnostics);
+    for (const error54 of extensionsResult.errors) {
+      console.error(`[warning] extension ${error54.path}: ${error54.error}`);
+    }
   }
   await session2.bindExtensions({});
-  const unsubscribe = session2.subscribe(renderEvent);
+  const subscriptions = [options3.onEvent ? session2.subscribe(options3.onEvent) : undefined];
   try {
-    console.error(`[session] ${session2.sessionId} cwd=${cwd}`);
-    await session2.prompt(prompt, { expandPromptTemplates: true });
+    if (options3.report)
+      console.error(`[session] ${session2.sessionId} cwd=${cwd}`);
+    await session2.prompt(options3.prompt, { expandPromptTemplates: true });
+    return { cwd, sessionId: session2.sessionId };
   } finally {
-    unsubscribe();
+    for (const unsubscribe of subscriptions)
+      unsubscribe?.();
     session2.dispose();
   }
 }
+async function runDoCommand(args) {
+  const options3 = parseDoCommand(args);
+  const prompt = options3.prompt;
+  if (!prompt)
+    throw new Error("`tsci-agent do` requires --prompt <text>.");
+  await runAgentPrompt({
+    prompt,
+    dir: options3.dir,
+    sandbox: options3.sandbox,
+    piArgs: options3.piArgs,
+    report: true,
+    onEvent: renderEvent
+  });
+}
 var init_do_command = __esm(() => {
   init_dist5();
   init_paths();

package/dist/diagnostics.d.ts

@@ -0,0 +1,4 @@
+export declare function reportDiagnostics(diagnostics: Array<{
+    type: string;
+    message: string;
+}>): void;

package/dist/do-command.d.ts

@@ -0,0 +1,21 @@
+import { type AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+export interface PreparedWorkingDirectory {
+    cwd: string;
+    sourceDir: string;
+    sandboxRoot?: string;
+}
+export interface AgentPromptResult {
+    cwd: string;
+    sessionId: string;
+}
+export interface AgentPromptOptions {
+    prompt: string;
+    dir: string;
+    sandbox?: boolean;
+    piArgs?: string[];
+    report?: boolean;
+    onEvent?: (event: AgentSessionEvent) => void;
+}
+export declare function prepareWorkingDirectory(dir: string, sandbox: boolean, report?: boolean): Promise<PreparedWorkingDirectory>;
+export declare function runAgentPrompt(options: AgentPromptOptions): Promise<AgentPromptResult>;
+export declare function runDoCommand(args: string[]): Promise<void>;

package/dist/interactive.d.ts

@@ -0,0 +1 @@
+export declare function runInteractive(args: string[]): Promise<void>;

package/dist/lib.d.ts

@@ -0,0 +1,41 @@
+import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+export interface SandboxFiles {
+    /** Return an absolute path inside the sandbox workspace. */
+    path(path: string): string;
+    /** List a directory inside the sandbox workspace. */
+    ls(path?: string): Promise<string[]>;
+    /** Read a UTF-8 file inside the sandbox workspace. */
+    read(path: string): Promise<string>;
+    /** Write a UTF-8 file inside the sandbox workspace, creating parent directories. */
+    write(path: string, content: string): Promise<void>;
+}
+export interface RunPromptInSandboxOptions {
+    /** Directory to copy into the sandbox. Defaults to process.cwd(). */
+    dir?: string;
+    /** Additional Pi SDK CLI-style args, for example ["--model", "openai/gpt-4.1"]. */
+    piArgs?: string[];
+    /** Observe raw Pi SDK session events while the prompt runs. */
+    onEvent?: (event: AgentSessionEvent) => void;
+}
+export interface SandboxPromptResult extends AsyncDisposable {
+    /** Assistant text emitted by the run. */
+    output: string;
+    /** Original directory copied into the sandbox. */
+    originalDir: string;
+    /** Temporary workspace directory where the prompt ran. */
+    sandboxDir: string;
+    /** Pi SDK session id used for the run. */
+    sessionId: string;
+    /** Convenience helpers scoped to sandboxDir. */
+    files: SandboxFiles;
+    /** Remove the temporary sandbox directory. Safe to call more than once. */
+    dispose(): Promise<void>;
+}
+/**
+ * Run a prompt against a temporary copy of a workspace and return helpers for
+ * inspecting that sandbox after the agent finishes.
+ *
+ * The sandbox is a filesystem copy, not a security boundary. Call dispose(), or
+ * use `await using`, to remove the temporary files when you are done reading them.
+ */
+export declare function runPromptInSandbox(prompt: string, options?: RunPromptInSandboxOptions): Promise<SandboxPromptResult>;