@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/session-manager.ts

@@ -1,150 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, statSync, symlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-export interface SessionMetadata {
-  project: string;
-  slug: string;
-  date: string;
-  path: string;
-  files: string[];
-}
-
-/**
- * Get all planning sessions organized by project.
- */
-export function getAllSessions(plansDir: string): Record<string, SessionMetadata[]> {
-  if (!existsSync(plansDir)) {
-    return {};
-  }
-
-  const result: Record<string, SessionMetadata[]> = {};
-  const projects = readdirSync(plansDir).filter((name) => {
-    const path = join(plansDir, name);
-    return statSync(path).isDirectory();
-  });
-
-  for (const project of projects) {
-    const projectDir = join(plansDir, project);
-    const sessions = readdirSync(projectDir)
-      .filter((name) => statSync(join(projectDir, name)).isDirectory())
-      .map((slug) => {
-        const sessionPath = join(projectDir, slug);
-        const files = existsSync(sessionPath) ? readdirSync(sessionPath) : [];
-        const date = slug.split("-").slice(0, 3).join("-"); // Extract YYYY-MM-DD
-
-        return {
-          project,
-          slug,
-          date,
-          path: sessionPath,
-          files,
-        };
-      })
-      .sort((a, b) => b.date.localeCompare(a.date)); // Most recent first
-
-    result[project] = sessions;
-  }
-
-  return result;
-}
-
-/**
- * Get a specific session.
- */
-export function getSession(
-  plansDir: string,
-  project: string,
-  slug: string,
-): SessionMetadata | undefined {
-  const allSessions = getAllSessions(plansDir);
-  return allSessions[project]?.find((s) => s.slug === slug);
-}
-
-/**
- * Create a new planning session.
- */
-export function createSession(plansDir: string, project: string, slug: string): SessionMetadata {
-  const projectDir = join(plansDir, project);
-  const sessionPath = join(projectDir, slug);
-
-  if (!existsSync(projectDir)) {
-    mkdirSync(projectDir, { recursive: true });
-  }
-
-  if (existsSync(sessionPath)) {
-    throw new Error(`Session already exists: ${sessionPath}`);
-  }
-
-  mkdirSync(sessionPath, { recursive: true });
-
-  // Create default files
-  const agentsMd = join(sessionPath, "AGENTS.md");
-  const claudeMd = join(sessionPath, "CLAUDE.md");
-  const planMd = join(sessionPath, "plan.md");
-
-  const agentsContent = `# ${project} - ${slug}
-
-## Context
-
-[Describe the problem/feature/task]
-
-## Background
-
-[Relevant context, constraints, decisions]
-
-## Goals
-
-[What we're trying to achieve]
-`;
-  writeFileSync(agentsMd, agentsContent);
-
-  writeFileSync(
-    planMd,
-    `# Implementation Plan
-
-## Overview
-
-[High-level approach]
-
-## Tasks
-
-- [ ] Task 1
-- [ ] Task 2
-- [ ] Task 3
-
-## Validation
-
-- [ ] Tests pass
-- [ ] Feature works as expected
-`,
-  );
-
-  // Canonical convention: CLAUDE.md is a symlink to AGENTS.md
-  try {
-    symlinkSync("AGENTS.md", claudeMd);
-  } catch {
-    // Symlink might fail on some systems (e.g. Windows without symlink support).
-    // Fall back to a copy so older tooling still finds CLAUDE.md.
-    writeFileSync(claudeMd, agentsContent);
-  }
-
-  return {
-    project,
-    slug,
-    date: slug.split("-").slice(0, 3).join("-"),
-    path: sessionPath,
-    files: ["CLAUDE.md", "AGENTS.md", "plan.md"],
-  };
-}
-
-/**
- * Generate a slug from a title.
- */
-export function generateSlug(title: string): string {
-  const date = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
-  const slug = title
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "");
-  return `${date}-${slug}`;
-}

package/src/lib/session-result.test.ts

@@ -1,98 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseSessionOutput, SESSION_RESULT_MAX_OUTPUT_CHARS } from "./session-result.js";
-
-describe("parseSessionOutput", () => {
-  it("parses pure JSON output", () => {
-    const output = parseSessionOutput('{"status":"success","confidence":9,"summary":"done"}');
-    expect(output.parsed).toEqual({
-      status: "success",
-      confidence: 9,
-      summary: "done",
-    });
-    expect(output.truncated).toBe(false);
-  });
-
-  it("extracts trailing JSON from noisy output", () => {
-    const raw = [
-      "Read files...",
-      "Run tests...",
-      "All good",
-      '{ "status": "success", "confidence": 8, "summary": "implemented" }',
-    ].join("\n");
-
-    const output = parseSessionOutput(raw);
-    expect(output.parsed).toEqual({
-      status: "success",
-      confidence: 8,
-      summary: "implemented",
-    });
-  });
-
-  it("extracts JSON from fenced code blocks", () => {
-    const raw = [
-      "Summary first",
-      "```json",
-      '{ "status": "partial", "confidence": 7, "summary": "needs polish" }',
-      "```",
-    ].join("\n");
-
-    const output = parseSessionOutput(raw);
-    expect(output.parsed).toEqual({
-      status: "partial",
-      confidence: 7,
-      summary: "needs polish",
-    });
-  });
-
-  it("prefers full output contract over nested JSON objects", () => {
-    const raw = [
-      "prelude logs",
-      "{",
-      '  "status": "success",',
-      '  "summary": "all done",',
-      '  "confidence": 9,',
-      '  "commit": { "created": true, "sha": "abc123" }',
-      "}",
-      "trailing text",
-    ].join("\n");
-
-    const output = parseSessionOutput(raw);
-    expect(output.parsed).toEqual({
-      status: "success",
-      summary: "all done",
-      confidence: 9,
-      commit: { created: true, sha: "abc123" },
-    });
-  });
-
-  it("repairs wrapped newlines inside JSON strings", () => {
-    const raw = [
-      "logs before json",
-      "{",
-      '  "status": "success",',
-      '  "summary": "AFS import/export and event-envelope interop for',
-      'annotations",',
-      '  "confidence": 9',
-      "}",
-    ].join("\n");
-
-    const output = parseSessionOutput(raw);
-    expect(output.parsed).toEqual({
-      status: "success",
-      summary: "AFS import/export and event-envelope interop for annotations",
-      confidence: 9,
-    });
-  });
-
-  it("returns null parsed value when no JSON exists", () => {
-    const output = parseSessionOutput("plain text only");
-    expect(output.parsed).toBeNull();
-  });
-
-  it("truncates output when over max chars", () => {
-    const raw = "x".repeat(SESSION_RESULT_MAX_OUTPUT_CHARS + 10);
-    const output = parseSessionOutput(raw);
-    expect(output.truncated).toBe(true);
-    expect(output.raw.length).toBe(SESSION_RESULT_MAX_OUTPUT_CHARS);
-  });
-});

package/src/lib/session-result.ts

@@ -1,262 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { AgentType } from "./types.js";
-
-export const SESSION_RESULT_MAX_OUTPUT_CHARS = 1_000_000;
-
-export type SessionResultStatus = "completed" | "failed" | "stopped";
-
-export interface SessionResult {
-  agent: AgentType;
-  artifacts: string[];
-  durationMs: number;
-  endedAt: string;
-  exitCode: number | null;
-  output: {
-    raw: string;
-    parsed: unknown;
-    truncated: boolean;
-  };
-  sessionId: string;
-  startedAt: string;
-  status: SessionResultStatus;
-  traceUrl?: string;
-}
-
-export interface SessionLogPaths {
-  outputPath: string;
-  resultPath: string;
-  stderrPath: string;
-  stdoutPath: string;
-}
-
-export function getSessionLogPaths(
-  sessionId: string,
-  promptsPath = join(homedir(), ".abbie", "prompts")
-): SessionLogPaths {
-  return {
-    outputPath: join(promptsPath, `${sessionId}-response.json`),
-    resultPath: join(promptsPath, `${sessionId}-result.json`),
-    stdoutPath: join(promptsPath, `${sessionId}-stdout.log`),
-    stderrPath: join(promptsPath, `${sessionId}-stderr.log`),
-  };
-}
-
-export function parseSessionOutput(
-  rawOutput: string,
-  maxChars = SESSION_RESULT_MAX_OUTPUT_CHARS
-): SessionResult["output"] {
-  const truncated = rawOutput.length > maxChars;
-  const raw = truncated ? rawOutput.slice(0, maxChars) : rawOutput;
-
-  const trimmed = raw.trim();
-  const parsed = extractParsedJson(trimmed);
-
-  return { raw, parsed, truncated };
-}
-
-function extractParsedJson(trimmed: string): unknown {
-  if (trimmed.length === 0) {
-    return null;
-  }
-
-  const direct = tryParseJson(trimmed);
-  if (direct !== null) {
-    return direct;
-  }
-
-  // Recover from noisy logs. Most agents append JSON at the end.
-  const tail = trimmed.slice(-200_000);
-  const candidates = [
-    ...collectFencedJsonCandidates(trimmed),
-    ...collectTailSuffixCandidates(tail, 250),
-    ...collectTailWindowCandidates(tail, 400),
-  ];
-
-  return pickBestParsed(candidates);
-}
-
-function isLikelyOutputContract(value: unknown): boolean {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-
-  const obj = value as Record<string, unknown>;
-  return (
-    typeof obj.status === "string" &&
-    typeof obj.summary === "string" &&
-    typeof obj.confidence === "number"
-  );
-}
-
-function tryParseJson(value: string): unknown {
-  try {
-    return JSON.parse(value);
-  } catch {
-    const repaired = repairBrokenJsonStrings(value);
-    if (repaired === value) {
-      return null;
-    }
-
-    try {
-      return JSON.parse(repaired);
-    } catch {
-      return null;
-    }
-  }
-}
-
-function repairBrokenJsonStrings(value: string): string {
-  let out = "";
-  let inString = false;
-  let escaped = false;
-
-  for (const ch of value) {
-    if (escaped) {
-      out += ch;
-      escaped = false;
-      continue;
-    }
-
-    if (inString && ch === "\\") {
-      out += ch;
-      escaped = true;
-      continue;
-    }
-
-    if (ch === '"') {
-      out += ch;
-      inString = !inString;
-      continue;
-    }
-
-    if (inString && (ch === "\n" || ch === "\r")) {
-      out += " ";
-      continue;
-    }
-
-    out += ch;
-  }
-
-  return out;
-}
-
-function collectFencedJsonCandidates(text: string): string[] {
-  const codeBlockRegex = /```(?:json)?\s*([\s\S]*?)```/gi;
-  const blocks: string[] = [];
-  for (const match of text.matchAll(codeBlockRegex)) {
-    const candidate = match[1]?.trim();
-    if (candidate) {
-      blocks.push(candidate);
-    }
-  }
-
-  return blocks.reverse();
-}
-
-function collectTailSuffixCandidates(tail: string, limit: number): string[] {
-  const candidates: string[] = [];
-  let count = 0;
-  let start = tail.lastIndexOf("{");
-
-  while (start !== -1 && count < limit) {
-    candidates.push(tail.slice(start).trim());
-    start = tail.lastIndexOf("{", start - 1);
-    count++;
-  }
-
-  return candidates;
-}
-
-function collectTailWindowCandidates(tail: string, limit: number): string[] {
-  const candidates: string[] = [];
-  let attempts = 0;
-  let end = tail.lastIndexOf("}");
-
-  while (end !== -1 && attempts < limit) {
-    let start = tail.lastIndexOf("{", end);
-    while (start !== -1 && attempts < limit) {
-      candidates.push(tail.slice(start, end + 1).trim());
-      start = tail.lastIndexOf("{", start - 1);
-      attempts++;
-    }
-    end = tail.lastIndexOf("}", end - 1);
-  }
-
-  return candidates;
-}
-
-function pickBestParsed(candidates: string[]): unknown {
-  let fallbackParsed: unknown = null;
-
-  for (const candidate of candidates) {
-    const parsed = tryParseJson(candidate);
-    if (parsed === null) {
-      continue;
-    }
-
-    if (isLikelyOutputContract(parsed)) {
-      return parsed;
-    }
-
-    if (fallbackParsed === null) {
-      fallbackParsed = parsed;
-    }
-  }
-
-  return fallbackParsed;
-}
-
-export function buildSessionResult(input: {
-  sessionId: string;
-  agent: AgentType;
-  status: SessionResultStatus;
-  exitCode: number | null;
-  startedAt: string;
-  endedAt: string;
-  rawOutput: string;
-  artifacts?: string[];
-  traceUrl?: string;
-}): SessionResult {
-  const startedMs = new Date(input.startedAt).getTime();
-  const endedMs = new Date(input.endedAt).getTime();
-  const durationMs =
-    Number.isFinite(startedMs) && Number.isFinite(endedMs) && endedMs >= startedMs
-      ? endedMs - startedMs
-      : 0;
-
-  return {
-    sessionId: input.sessionId,
-    agent: input.agent,
-    status: input.status,
-    exitCode: input.exitCode,
-    startedAt: input.startedAt,
-    endedAt: input.endedAt,
-    durationMs,
-    output: parseSessionOutput(input.rawOutput),
-    artifacts: input.artifacts ?? [],
-    ...(input.traceUrl ? { traceUrl: input.traceUrl } : {}),
-  };
-}
-
-export function readSessionResult(path: string): SessionResult | null {
-  if (!existsSync(path)) {
-    return null;
-  }
-
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    if (
-      !parsed ||
-      typeof parsed !== "object" ||
-      typeof parsed.sessionId !== "string" ||
-      typeof parsed.status !== "string"
-    ) {
-      return null;
-    }
-    return parsed as SessionResult;
-  } catch {
-    return null;
-  }
-}