@fiale-plus/pi-rogue-bundle 0.1.14 → 0.1.16

package/README.md

@@ -4,7 +4,9 @@
 
 It stitches together (and bundles for a true single-package install):
 
+- `@fiale-plus/pi-core` (shared contracts/helpers)
 - `@fiale-plus/pi-rogue-advisor` (logic; direct releases paused)
+- `@fiale-plus/pi-rogue-context-broker` (beta context-broker runtime; disabled by default)
 - `@fiale-plus/pi-rogue-orchestration` (logic; direct releases paused)
 
 Direct installs of the advisor/orchestration packages are paused (marked private). All users and future releases go through the bundle. See `docs/release.md` and root `AGENTS.md` / `README.md` for the release policy.
@@ -26,12 +28,16 @@ npm install
 ## Scope boundaries
 
 - **Lab / internal helpers are excluded from this bundle.**
+- The beta context-broker runtime is bundled for opt-in experiments but is not registered/enabled by default.
+- Opt-in consumers can import the runtime through the bundle subpath: `@fiale-plus/pi-rogue-bundle/context-broker`.
+- Set `PI_CONTEXT_BROKER_ENABLED=true` before starting Pi to register the beta `/context` command surface.
 - `@fiale-plus/pi-rogue-bundle` is the only published surface for the logic.
 - Internal helper packages (`@fiale-plus/pi-rogue-guardrails`, `@fiale-plus/pi-rogue-brain`, `@fiale-plus/pi-rogue-repo-arch`) are maintained separately in the lab section and not published.
 
 ## Command surface
 
-- `/advisor`, `/goal`, `/loop`, `/autoresearch`, `/autoresearch-lab` plus status/config/command paths (all provided via the bundle).
+- Default: `/advisor`, `/goal`, `/loop`, `/autoresearch`, `/autoresearch-lab` plus status/config/command paths (all provided via the bundle).
+- Opt-in beta: `PI_CONTEXT_BROKER_ENABLED=true` adds `/context status`, `/context brief`, `/context lookup <handle|text>`, `/context pin <handle>`, and `/context prune` with autocomplete.
 
 ## Status
 

package/node_modules/@fiale-plus/pi-core/README.md

@@ -0,0 +1,13 @@
+# Pi-Rogue Core
+
+Shared helpers for the Pi-Rogue workspace.
+
+Includes shared bounded context broker contracts:
+
+- `BoundedContextBroker`
+- `ContextArtifact` / `ContextArtifactInput`
+- lookup, retention, and status type definitions
+
+The executable in-memory implementation lives in `@fiale-plus/pi-rogue-context-broker`.
+
+Install locally from this repo root: `npm install`

package/node_modules/@fiale-plus/pi-core/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@fiale-plus/pi-core",
+  "version": "0.1.0",
+  "description": "Shared helpers for the Pi-Rogue workspace.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi-package"
+  ],
+  "scripts": {
+    "test": "cd ../.. && vitest run packages/core/src/*.test.ts"
+  },
+  "private": true,
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@fiale-plus/pi-core/src/context-broker.ts

@@ -0,0 +1,81 @@
+export type ContextArtifactKind =
+  | "tool_output"
+  | "diff"
+  | "file_snapshot"
+  | "subagent_result"
+  | "advisor_brief"
+  | "memory_note";
+
+export interface ContextArtifactInput {
+  sessionId: string;
+  kind: ContextArtifactKind;
+  payload: string | Buffer;
+  summary?: string;
+  tags?: string[];
+  paths?: string[];
+  command?: string;
+  branch?: string;
+  ttlMs?: number;
+  pinned?: boolean;
+  parentIds?: string[];
+  createdAt?: number;
+}
+
+export interface ContextArtifact {
+  id: string;
+  handle: string;
+  sessionId: string;
+  kind: ContextArtifactKind;
+  createdAt: number;
+  updatedAt: number;
+  bytes: number;
+  sha256: string;
+  payload: string;
+  summary: string;
+  tags: string[];
+  paths: string[];
+  command?: string;
+  branch?: string;
+  expiresAt?: number;
+  pinned: boolean;
+  parentIds: string[];
+}
+
+export interface ContextLookupQuery {
+  id?: string;
+  handle?: string;
+  sessionId?: string;
+  kind?: ContextArtifactKind;
+  tag?: string;
+  path?: string;
+  commandPrefix?: string;
+  branch?: string;
+  text?: string;
+  limit?: number;
+}
+
+export interface ContextBrokerStatus {
+  records: number;
+  bytes: number;
+  pinnedRecords: number;
+  pinnedBytes: number;
+  maxRecords: number;
+  maxBytes: number;
+}
+
+export interface ContextBrokerOptions {
+  maxRecords?: number;
+  maxBytes?: number;
+  defaultTtlMs?: number;
+  summaryBytes?: number;
+  briefBytes?: number;
+}
+
+export interface BoundedContextBroker {
+  publish(input: ContextArtifactInput): ContextArtifact;
+  lookup(query?: ContextLookupQuery): ContextArtifact[];
+  pin(idOrHandle: string, pinned?: boolean): ContextArtifact | null;
+  prune(now?: number): ContextBrokerStatus;
+  status(): ContextBrokerStatus;
+  renderBrief(query?: ContextLookupQuery & { budgetBytes?: number }): string;
+}

package/node_modules/@fiale-plus/pi-core/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./context-broker.js";
+export * from "./paths.js";
+export * from "./risk.js";
+export * from "./storage.js";
+export * from "./text.js";

package/node_modules/@fiale-plus/pi-core/src/paths.ts

@@ -0,0 +1,36 @@
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+
+const ROOT_DIR = join(homedir(), ".pi", "agent", "fiale-plus");
+
+export function appDir(): string {
+  mkdirSync(ROOT_DIR, { recursive: true });
+  return ROOT_DIR;
+}
+
+export function featureDir(feature: string): string {
+  const dir = join(appDir(), feature);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function sessionKey(ctx: any): string {
+  const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+  if (!sessionFile) return "session";
+  return basename(String(sessionFile)).replace(/\.[^.]+$/, "");
+}
+
+export function sessionDir(feature: string, ctx: any): string {
+  const dir = join(featureDir(feature), sessionKey(ctx));
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function featureFile(feature: string, filename: string): string {
+  return join(featureDir(feature), filename);
+}
+
+export function sessionFile(feature: string, ctx: any, filename: string): string {
+  return join(sessionDir(feature, ctx), filename);
+}

package/node_modules/@fiale-plus/pi-core/src/risk.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import { scanShellCommand, type RiskScan } from "./risk.js";
+
+describe("scanShellCommand", () => {
+  it("returns safe for empty command", () => {
+    const result = scanShellCommand("");
+    expect(result.safe).toBe(true);
+    expect(result.severity).toBe("safe");
+  });
+
+  it("returns safe for a benign command", () => {
+    const result = scanShellCommand("echo hello world");
+    expect(result.safe).toBe(true);
+    expect(result.severity).toBe("safe");
+  });
+
+  it("detects rm as dangerous", () => {
+    const result = scanShellCommand("rm -rf /tmp/foo");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "rm")).toBe(true);
+  });
+
+  it("detects rm only as a word boundary (not inside other words)", () => {
+    const result = scanShellCommand("program --remove-all");
+    expect(result.safe).toBe(true);
+  });
+
+  it("detects sudo as warning", () => {
+    const result = scanShellCommand("sudo apt update");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("warn");
+    expect(result.findings.some((f) => f.id === "sudo")).toBe(true);
+  });
+
+  it("detects chmod -R as dangerous", () => {
+    const result = scanShellCommand("chmod -R 777 /etc");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "chmod-r")).toBe(true);
+  });
+
+  it("detects chown as dangerous", () => {
+    const result = scanShellCommand("chown root:root /var");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects git push --force as dangerous", () => {
+    const result = scanShellCommand("git push --force origin main");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "force-push")).toBe(true);
+  });
+
+  it("detects git push --force-with-lease as dangerous", () => {
+    const result = scanShellCommand("git push --force-with-lease origin main");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "force-push")).toBe(true);
+  });
+
+  it("detects curl | sh as dangerous", () => {
+    const result = scanShellCommand("curl https://example.com/install.sh | sh");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "curl-shell")).toBe(true);
+  });
+
+  it("detects curl | bash as dangerous", () => {
+    const result = scanShellCommand("curl -fsSL https://example.com/install.sh | bash");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+    expect(result.findings.some((f) => f.id === "curl-shell")).toBe(true);
+  });
+
+  it("detects mkfs as dangerous", () => {
+    const result = scanShellCommand("mkfs.ext4 /dev/sda1");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects dd if= as dangerous", () => {
+    const result = scanShellCommand("dd if=/dev/zero of=/tmp/out bs=1M count=10");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects shutdown as dangerous", () => {
+    const result = scanShellCommand("shutdown -h now");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("detects reboot as dangerous", () => {
+    const result = scanShellCommand("reboot");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("scans extra fragments", () => {
+    const result = scanShellCommand("docker exec -it container bash", ["docker exec"]);
+    expect(result.safe).toBe(false);
+    expect(result.findings.some((f) => f.id === "extra:docker exec")).toBe(true);
+  });
+
+  it("returns warn severity when only warnings are found", () => {
+    const result = scanShellCommand("sudo echo hello");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("warn");
+  });
+
+  it("returns danger severity when danger items are found even with warnings", () => {
+    const result = scanShellCommand("sudo rm /tmp/foo");
+    expect(result.safe).toBe(false);
+    expect(result.severity).toBe("danger");
+  });
+
+  it("handles case-insensitive matching", () => {
+    const result = scanShellCommand("RM -rf /");
+    expect(result.safe).toBe(false);
+    expect(result.findings.some((f) => f.id === "rm")).toBe(true);
+  });
+
+  it("ignores empty extra fragments", () => {
+    const result = scanShellCommand("echo foo", ["", "  "]);
+    expect(result.safe).toBe(true);
+  });
+});

package/node_modules/@fiale-plus/pi-core/src/risk.ts

@@ -0,0 +1,97 @@
+export interface RiskFinding {
+  id: string;
+  label: string;
+  severity: "warn" | "danger";
+}
+
+export interface RiskScan {
+  safe: boolean;
+  severity: "safe" | "warn" | "danger";
+  findings: RiskFinding[];
+  reason: string;
+}
+
+const DEFAULT_PATTERNS: RiskFinding[] = [
+  { id: "rm", label: "rm", severity: "danger" },
+  { id: "sudo", label: "sudo", severity: "warn" },
+  { id: "chmod-r", label: "chmod -R", severity: "danger" },
+  { id: "chown", label: "chown", severity: "danger" },
+  { id: "mkfs", label: "mkfs", severity: "danger" },
+  { id: "dd", label: "dd if=", severity: "danger" },
+  { id: "shutdown", label: "shutdown", severity: "danger" },
+  { id: "reboot", label: "reboot", severity: "danger" },
+  { id: "force-push", label: "git push --force", severity: "danger" },
+  { id: "curl-shell", label: "curl | sh", severity: "danger" },
+  { id: "wget-shell", label: "wget | sh", severity: "danger" },
+];
+
+function contains(command: string, fragment: string): boolean {
+  return command.toLowerCase().includes(fragment.toLowerCase());
+}
+
+export function scanShellCommand(command: string, extraFragments: string[] = []): RiskScan {
+  const findings: RiskFinding[] = [];
+  const text = command.trim();
+
+  if (!text) {
+    return { safe: true, severity: "safe", findings, reason: "Empty command." };
+  }
+
+  for (const pattern of DEFAULT_PATTERNS) {
+    switch (pattern.id) {
+      case "rm":
+        if (/\brm\b/i.test(text)) findings.push(pattern);
+        break;
+      case "sudo":
+        if (/\bsudo\b/i.test(text)) findings.push(pattern);
+        break;
+      case "chmod-r":
+        if (/\bchmod\s+-R\b/i.test(text)) findings.push(pattern);
+        break;
+      case "chown":
+        if (/\bchown\b/i.test(text)) findings.push(pattern);
+        break;
+      case "mkfs":
+        if (/\bmkfs(?:\.[\w-]+)?\b/i.test(text)) findings.push(pattern);
+        break;
+      case "dd":
+        if (/\bdd\s+if=/i.test(text)) findings.push(pattern);
+        break;
+      case "shutdown":
+        if (/\bshutdown\b/i.test(text)) findings.push(pattern);
+        break;
+      case "reboot":
+        if (/\breboot\b/i.test(text)) findings.push(pattern);
+        break;
+      case "force-push":
+        if (/\bgit\s+push\b[\s\S]*--force(?:-with-lease)?/i.test(text)) findings.push(pattern);
+        break;
+      case "curl-shell":
+        if (/\bcurl\b[\s\S]*\|\s*(sh|bash)\b/i.test(text)) findings.push(pattern);
+        break;
+      case "wget-shell":
+        if (/\bwget\b[\s\S]*\|\s*(sh|bash)\b/i.test(text)) findings.push(pattern);
+        break;
+    }
+  }
+
+  for (const fragment of extraFragments) {
+    if (!fragment.trim()) continue;
+    if (contains(text, fragment)) {
+      findings.push({ id: `extra:${fragment}`, label: fragment, severity: "danger" });
+    }
+  }
+
+  if (findings.length === 0) {
+    return { safe: true, severity: "safe", findings, reason: "No risky shell fragments found." };
+  }
+
+  const severity = findings.some((finding) => finding.severity === "danger") ? "danger" : "warn";
+  const labels = findings.map((finding) => finding.label).join(", ");
+  return {
+    safe: false,
+    severity,
+    findings,
+    reason: `Detected risky shell fragment(s): ${labels}`,
+  };
+}

package/node_modules/@fiale-plus/pi-core/src/storage.ts

@@ -0,0 +1,39 @@
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function ensureParent(filePath: string): string {
+  mkdirSync(dirname(filePath), { recursive: true });
+  return filePath;
+}
+
+export function readText(filePath: string, fallback = ""): string {
+  try {
+    return readFileSync(filePath, "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeText(filePath: string, text: string): void {
+  ensureParent(filePath);
+  writeFileSync(filePath, text, "utf8");
+}
+
+export function appendText(filePath: string, text: string): void {
+  ensureParent(filePath);
+  appendFileSync(filePath, text, "utf8");
+}
+
+export function readJson<T>(filePath: string, fallback: T): T {
+  try {
+    const raw = readText(filePath).trim();
+    if (!raw) return fallback;
+    return JSON.parse(raw) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export function writeJson(filePath: string, value: unknown): void {
+  writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}

package/node_modules/@fiale-plus/pi-core/src/text.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { truncate, safeName } from "./text.js";
+
+describe("truncate", () => {
+  it("returns full text when within limit", () => {
+    expect(truncate("hello", 10)).toBe("hello");
+  });
+
+  it("truncates and appends ellipsis when over limit", () => {
+    const result = truncate("hello world this is long", 12);
+    expect(result).toHaveLength(12);
+    expect(result.endsWith("…")).toBe(true);
+  });
+
+  it("handles empty string", () => {
+    expect(truncate("", 10)).toBe("");
+  });
+});
+
+describe("safeName", () => {
+  it("lowercases and replaces spaces with hyphens", () => {
+    expect(safeName("My Feature Branch")).toBe("my-feature-branch");
+  });
+
+  it("replaces special characters with hyphens", () => {
+    expect(safeName("feature/auth!!@#")).toBe("feature-auth");
+  });
+
+  it("strips leading/trailing hyphens", () => {
+    expect(safeName("--main--")).toBe("main");
+  });
+
+  it("falls back to 'main' for empty input", () => {
+    expect(safeName("")).toBe("main");
+  });
+});

package/node_modules/@fiale-plus/pi-core/src/text.ts

@@ -0,0 +1,14 @@
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+
+export function safeName(text: string): string {
+  return (
+    text
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9._-]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "main"
+  );
+}

package/node_modules/@fiale-plus/pi-rogue-context-broker/README.md

@@ -0,0 +1,38 @@
+# Pi-Rogue Context Broker
+
+Beta context broker runtime for Pi-Rogue.
+
+This package contains the executable in-memory bounded broker implementation:
+
+- `createInMemoryContextBroker()` stores artifacts behind stable `ctx://...` handles.
+- Lookups support handle, session, kind, tag, path, command prefix, branch, and text filters.
+- Omitted summaries become metadata-only placeholders, keeping raw payloads out of prompt briefs by default.
+- Pruning enforces per-session record/byte caps, TTL expiry on reads, and pinned-artifact retention.
+
+It is intentionally disabled by default in the bundle.
+
+## Opt-in beta extension
+
+Set `PI_CONTEXT_BROKER_ENABLED=true` before starting Pi with the bundle installed to enable the beta extension:
+
+```bash
+PI_CONTEXT_BROKER_ENABLED=true pi
+```
+
+When enabled, the bundle registers `/context` commands:
+
+- `/context status` — enabled state, record/byte counts, pinned counts.
+- `/context brief` — bounded prompt-safe broker brief with handles and summaries.
+- `/context lookup <handle|text>` — exact handle rehydration or current-session text search.
+- `/context pin <handle>` — protect an artifact from normal TTL/cap pruning.
+- `/context prune` — run TTL/cap pruning immediately.
+
+The command includes autocomplete for subcommands and known artifact handles. Exact handle lookup returns clipped payload text; text search returns a smaller clipped excerpt, and truncation is marked explicitly.
+
+## Session behavior and limits
+
+- On session start/reload, the beta backfills the current Pi session branch from `toolResult` and prompt-visible `bashExecution` entries.
+- Backfill is idempotent by session entry id, skips malformed entries instead of failing the session, and honors Pi's `excludeFromContext` bash entries.
+- The current implementation remains in-memory. Restarting Pi loses broker state until the current branch is backfilled again.
+- Prompt integration injects only a bounded broker brief and lookup guidance. It does not yet rewrite existing raw tool-result messages out of Pi's transcript context; that deeper prompt-load reduction remains a follow-up.
+- Rollback is immediate: unset `PI_CONTEXT_BROKER_ENABLED` and `/reload` or restart Pi.

package/node_modules/@fiale-plus/pi-rogue-context-broker/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@fiale-plus/pi-rogue-context-broker",
+  "version": "0.1.0",
+  "description": "Beta context broker runtime for Pi-Rogue. In-memory bounded broker implementation behind explicit opt-in.",
+  "private": true,
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi-package"
+  ],
+  "scripts": {
+    "check": "tsc -p ../../tsconfig.json --noEmit",
+    "test": "cd ../.. && vitest run packages/context-broker/src/*.test.ts"
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./extension": "./src/extension.ts"
+  },
+  "dependencies": {
+    "@fiale-plus/pi-core": "^0.1.0"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "package.json"
+  ]
+}