pi-harness-runtime 1.1.0 → 1.1.2

package/packages/notification/src/adapters/line-adapter.ts

@@ -0,0 +1,119 @@
+/**
+ * LINE Adapter — RFC-0022
+ *
+ * Sends notifications via LINE Messaging API.
+ */
+
+import type {
+	NotificationPayload,
+	NotificationResult,
+	LineConfig,
+} from "../types.js";
+import { BaseChannelAdapter } from "../base-adapter.js";
+
+export class LineAdapter extends BaseChannelAdapter {
+	readonly id = "line";
+	readonly type = "line";
+
+	constructor(config: LineConfig) {
+		super({ id: "line", type: "line", enabled: true, config });
+	}
+
+	async initialize(): Promise<boolean> {
+		try {
+			const cfg = this.config.config as LineConfig;
+			// Verify access token by getting profile
+			const response = await fetch(
+				"https://api.line.me/v2/bot/profile",
+				{
+					headers: {
+						Authorization: `Bearer ${cfg.channelAccessToken}`,
+					},
+				},
+			);
+			return response.ok;
+		} catch {
+			return false;
+		}
+	}
+
+	async send(payload: NotificationPayload): Promise<NotificationResult> {
+		try {
+			const cfg = this.config.config as LineConfig;
+			const message = this.formatMessage(payload);
+
+			const response = await fetch(
+				"https://api.line.me/v2/bot/message/push",
+				{
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						Authorization: `Bearer ${cfg.channelAccessToken}`,
+					},
+					body: JSON.stringify({
+						to: cfg.userId,
+						messages: [
+							{
+								type: "text",
+								text: message,
+							},
+						],
+					}),
+				},
+			);
+
+			if (!response.ok) {
+				const error = await response.text();
+				return {
+					success: false,
+					channel: this.id,
+					error: `LINE API error: ${error}`,
+				};
+			}
+
+			return { success: true, channel: this.id };
+		} catch (error) {
+			return {
+				success: false,
+				channel: this.id,
+				error: String(error),
+			};
+		}
+	}
+
+	private formatMessage(payload: NotificationPayload): string {
+		const emoji = this.getEmoji(payload.event);
+		const title = `${emoji} ${payload.title}`;
+		const lines = [title, "", payload.message];
+
+		if (payload.details?.taskTitle) {
+			lines.push("", `Task: ${payload.details.taskTitle}`);
+		}
+		if (payload.details?.jobId) {
+			lines.push(`Job: ${payload.details.jobId}`);
+		}
+		if (payload.details?.error) {
+			lines.push("", `Error: ${payload.details.error}`);
+		}
+
+		return lines.filter(Boolean).join("\n");
+	}
+
+	private getEmoji(event: NotificationPayload["event"]): string {
+		const map: Record<string, string> = {
+			JobStarted: "🚀",
+			TaskCompleted: "✅",
+			TaskFailed: "❌",
+			QuotaPaused: "⏸️",
+			ResumeScheduled: "▶️",
+			ContextCompacted: "📦",
+			OutputLimitContinued: "🔄",
+			E2EFailed: "🧪",
+			HumanReviewNeeded: "👤",
+			ReadyForClient: "🎉",
+			JobCancelled: "🚫",
+			Error: "⚠️",
+		};
+		return map[event] ?? "📢";
+	}
+}

package/packages/notification/src/index.ts

@@ -7,3 +7,4 @@
 export * from "./notification-center.js";
 export * from "./base-adapter.js";
 export * from "./types.js";
+export { LineAdapter } from "./adapters/line-adapter.js";

package/packages/notification/src/notification-center.ts

@@ -19,6 +19,7 @@ import type {
 } from "./types.js";
 import type { ChannelAdapter } from "./base-adapter.js";
 import { TelegramAdapter } from "./adapters/telegram-adapter.js";
+import { LineAdapter } from "./adapters/line-adapter.js";
 import { NtfyAdapter } from "./adapters/ntfy-adapter.js";
 import { EmailAdapter } from "./adapters/email-adapter.js";
 import { WebhookAdapter } from "./adapters/webhook-adapter.js";
@@ -168,6 +169,10 @@ export class NotificationCenter {
 				return new WebhookAdapter(
 					config.config as import("./types.js").WebhookConfig,
 				);
+			case "line":
+				return new LineAdapter(
+					config.config as import("./types.js").LineConfig,
+				);
 			default:
 				return null;
 		}
@@ -276,6 +281,7 @@ export class NotificationCenter {
 	private getDefaultRedactPatterns(): RegExp[] {
 		return [
 			/Bearer\s+[\w-]+/gi, // Bearer tokens
+			/channel[_-]?access[_-]?token["\s:=]+[^\s,}]+/gi, // LINE channel access token
 			/password["\s:=]+[^\s,}]+/gi, // passwords
 			/cookie["\s:=]+[^\s,}]+/gi, // cookies
 			/secret["\s:=]+[^\s,}]+/gi, // secrets

package/packages/notification/src/types.ts

@@ -40,10 +40,10 @@ export interface NotificationChannelConfig {
 	id: string;
 	type: NotificationChannelType;
 	enabled: boolean;
-	config: TelegramConfig | NtfyConfig | EmailConfig | WebhookConfig;
+	config: TelegramConfig | NtfyConfig | EmailConfig | WebhookConfig | LineConfig;
 }
 
-export type NotificationChannelType = "telegram" | "ntfy" | "email" | "webhook";
+export type NotificationChannelType = "telegram" | "ntfy" | "email" | "webhook" | "line";
 
 export interface TelegramConfig {
 	botToken: string;
@@ -74,6 +74,11 @@ export interface WebhookConfig {
 	authToken?: string;
 }
 
+export interface LineConfig {
+	channelAccessToken: string;
+	userId: string;
+}
+
 export interface NotificationResult {
 	success: boolean;
 	channel: string;

package/packages/observability/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/observability",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "Comprehensive observability system with structured logging, tracing, metrics, and alerting",
   "type": "module",
   "main": "./dist/index.js",

package/packages/okf-indexer/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@pi-harness/okf-indexer",
+  "version": "0.10.30",
+  "description": "OKF document indexer for SKILL.md files (RFC-0106)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc --skipLibCheck",
+    "index": "bun run src/cli.ts"
+  }
+}

package/packages/okf-indexer/src/cli.ts

@@ -0,0 +1,25 @@
+/**
+ * CLI for indexing SKILL.md files (RFC-0106)
+ *
+ * Usage:
+ *   bun run index [directory] [--output <file>] [--format json|codegraph]
+ */
+
+import { indexDirectory, toCodeGraph, type OKFDocument } from "./indexer.js";
+
+const args = process.argv.slice(2);
+const dir = args[0] || ".";
+const outputArg = args.indexOf("--output");
+const outputFile = outputArg >= 0 ? args[outputArg + 1] : null;
+
+const docs = indexDirectory(dir);
+console.error(`Indexed ${docs.length} skills from ${dir}`);
+
+if (outputFile) {
+  const fs = await import("node:fs");
+  const data = docs.map((d) => ({ ...d, _graph: toCodeGraph(d) }));
+  fs.writeFileSync(outputFile, JSON.stringify(data, null, 2));
+  console.error(`Written to ${outputFile}`);
+} else {
+  console.log(JSON.stringify(docs, null, 2));
+}

package/packages/okf-indexer/src/indexer.ts

@@ -0,0 +1,186 @@
+/**
+ * OKF Indexer (RFC-0106)
+ *
+ * Parses SKILL.md files and extracts structured knowledge for
+ * indexing into TencentDB-Agent-Memory CodeGraph.
+ */
+
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative, basename } from "node:path";
+
+/**
+ * OKF Document structure
+ */
+export interface OKFDocument {
+  id: string;
+  title: string;
+  slug: string;
+  sections: OKFSection[];
+  links: string[];
+  metadata: OKFMetadata;
+}
+
+export interface OKFSection {
+  id: string;
+  title: string;
+  content: string;
+  level: number;
+  bullets: string[];
+}
+
+export interface OKFMetadata {
+  source: string;
+  tags: string[];
+  created: string;
+  updated: string;
+  scope?: string;
+}
+
+/**
+ * Parse frontmatter from SKILL.md
+ */
+function parseFrontmatter(content: string): Record<string, string | string[]> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+
+  const result: Record<string, string | string[]> = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx <= 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const val = line.slice(colonIdx + 1).trim();
+    if (val.startsWith("[") && val.endsWith("]")) {
+      result[key] = val.slice(1, -1).split(",").map((s) => s.trim());
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+/**
+ * Extract markdown sections
+ */
+function extractSections(content: string): OKFSection[] {
+  const sections: OKFSection[] = [];
+  const lines = content.split("\n");
+  let current: Partial<OKFSection> | null = null;
+  let bodyLines: string[] = [];
+
+  for (const line of lines) {
+    const h2 = line.match(/^## (.+)/);
+    const h3 = line.match(/^### (.+)/);
+
+    if (h2 || h3) {
+      if (current && current.title) {
+        sections.push({
+          id: current.id!,
+          title: current.title,
+          content: bodyLines.join("\n").trim(),
+          level: current.level!,
+          bullets: bodyLines.filter((l) => l.trim().startsWith("- ")).map((l) => l.replace(/^-\s*/, "").trim()),
+        });
+      }
+      current = {
+        id: (h2 || h3)![1].toLowerCase().replace(/\s+/g, "-"),
+        title: (h2 || h3)![1],
+        level: h2 ? 2 : 3,
+      };
+      bodyLines = [];
+    } else {
+      bodyLines.push(line);
+    }
+  }
+
+  if (current && current.title) {
+    sections.push({
+      id: current.id!,
+      title: current.title,
+      content: bodyLines.join("\n").trim(),
+      level: current.level!,
+      bullets: bodyLines.filter((l) => l.trim().startsWith("- ")).map((l) => l.replace(/^-\s*/, "").trim()),
+    });
+  }
+
+  return sections;
+}
+
+/**
+ * Extract wiki-style links
+ */
+function extractLinks(content: string): string[] {
+  const links: string[] = [];
+  const regex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+  let m;
+  while ((m = regex.exec(content)) !== null) links.push(m[1]);
+  return [...new Set(links)];
+}
+
+/**
+ * Index a single SKILL.md file
+ */
+export function indexSkill(filePath: string, basePath: string): OKFDocument | null {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const fm = parseFrontmatter(content);
+    const sections = extractSections(content);
+    const links = extractLinks(content);
+    const name = basename(filePath, ".md");
+
+    return {
+      id: name.toLowerCase().replace(/\s+/g, "-"),
+      title: (fm.name as string) || name,
+      slug: name,
+      sections,
+      links,
+      metadata: {
+        source: relative(basePath, filePath),
+        tags: Array.isArray(fm.tags) ? fm.tags : [],
+        created: (fm.created as string) || new Date().toISOString(),
+        updated: new Date().toISOString(),
+        scope: fm.scope as string,
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Index all skills in a directory
+ */
+export function indexDirectory(dirPath: string): OKFDocument[] {
+  const docs: OKFDocument[] = [];
+
+  function walk(current: string) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      const full = join(current, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (entry.name === "SKILL.md" || entry.name.endsWith(".skill.md")) {
+        const doc = indexSkill(full, dirPath);
+        if (doc) docs.push(doc);
+      }
+    }
+  }
+
+  walk(dirPath);
+  return docs;
+}
+
+/**
+ * Convert OKF document to CodeGraph nodes/edges for TencentDB
+ */
+export function toCodeGraph(doc: OKFDocument): {
+  nodes: Array<{ id: string; type: string; data: Record<string, unknown> }>;
+  edges: Array<{ from: string; to: string; type: string }>;
+} {
+  const nodes = [
+    { id: doc.id, type: "skill", data: { title: doc.title, slug: doc.slug, source: doc.metadata.source } },
+    ...doc.sections.map((s) => ({ id: `${doc.id}#${s.id}`, type: "section", data: { title: s.title, level: s.level } })),
+  ];
+
+  const edges = doc.sections.map((s) => ({ from: doc.id, to: `${doc.id}#${s.id}`, type: "has_section" }));
+  edges.push(...doc.links.map((l) => ({ from: doc.id, to: l.toLowerCase().replace(/\s+/g, "-"), type: "links_to" })));
+
+  return { nodes, edges };
+}

package/packages/performance-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/performance-optimizer",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "Performance optimization analyzer for pi-harness runtime (RFC-0056)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/privilege-broker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/privilege-broker",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "Privilege Broker — capability registry and command executor for autonomous runtime (RFC-0101 §7)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/project-analyzer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/project-analyzer",
-  "version": "1.1.0",
+  "version": "0.10.30",
   "description": "Project analysis system for pi-harness-runtime - detects frameworks, rules, and project structure",
   "type": "module",
   "main": "./dist/index.js",

package/packages/project-bootstrap/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@pi-harness/project-bootstrap",
+  "version": "0.10.30",
+  "description": "Project scaffolding from typed ProjectSpec",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Tests not configured\""
+  },
+  "dependencies": {
+    "@pi/framework-detector": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0"
+  }
+}

package/packages/project-bootstrap/src/bootstrap.ts

@@ -0,0 +1,166 @@
+/**
+ * Project Bootstrap - RFC-0072
+ *
+ * Main bootstrap orchestration.
+ */
+
+import type {
+  ProjectSpec,
+  BootstrapOptions,
+  BootstrapResult,
+  ValidationError,
+  Template,
+} from './types.js';
+import { minimalTemplate } from './minimal.js';
+import { nodeTypescriptTemplate } from './typescript.js';
+import { frappeTemplate } from './frappe.js';
+
+// Built-in templates
+const TEMPLATES: Record<string, Template> = {
+  minimal: minimalTemplate,
+  'node-typescript': nodeTypescriptTemplate,
+  'frappe-app': frappeTemplate,
+};
+
+/**
+ * Validate a project spec
+ */
+export function validateSpec(spec: ProjectSpec): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  if (!spec.name || spec.name.trim() === '') {
+    errors.push({ field: 'name', message: 'Name is required' });
+  }
+
+  if (!spec.type || !['monorepo', 'single-package', 'multi-package'].includes(spec.type)) {
+    errors.push({ field: 'type', message: 'Type must be monorepo, single-package, or multi-package' });
+  }
+
+  if (!spec.frameworks || spec.frameworks.length === 0) {
+    errors.push({ field: 'frameworks', message: 'At least one framework is required' });
+  }
+
+  return errors;
+}
+
+/**
+ * Get template for a spec
+ */
+export function getTemplateForSpec(spec: ProjectSpec, override?: string): Template {
+  if (override && TEMPLATES[override]) {
+    return TEMPLATES[override];
+  }
+
+  // Auto-detect based on frameworks
+  if (spec.frameworks.includes('frappe')) {
+    return TEMPLATES['frappe-app'];
+  }
+
+  if (spec.frameworks.includes('node') || spec.frameworks.includes('typescript')) {
+    return TEMPLATES['node-typescript'];
+  }
+
+  return TEMPLATES['minimal'];
+}
+
+/**
+ * Bootstrap a project from a spec
+ */
+export async function bootstrap(
+  spec: ProjectSpec,
+  targetDir: string,
+  options: BootstrapOptions = {}
+): Promise<BootstrapResult> {
+  const startTime = Date.now();
+  const errors = validateSpec(spec);
+
+  if (errors.length > 0) {
+    throw new Error(`Invalid spec: ${errors.map(e => e.message).join(', ')}`);
+  }
+
+  const { mkdir, writeFile } = await import('fs/promises');
+  const { join } = await import('path');
+
+  // Create target directory
+  await mkdir(targetDir, { recursive: true });
+
+  // Get template
+  const template = getTemplateForSpec(spec, options.template);
+
+  // Emit started event
+  if (options.verbose) {
+    console.log(`Bootstrap: ${spec.name} using template: ${template.name}`);
+  }
+
+  // Apply template
+  const files = await template.apply(spec, targetDir);
+
+  // Create gitignore if gitInit
+  if (spec.gitInit) {
+    const gitignore = `node_modules/\ndist/\n.env\n*.log\n`;
+    await writeFile(join(targetDir, '.gitignore'), gitignore);
+    files.push('.gitignore');
+  }
+
+  const result: BootstrapResult = {
+    root: targetDir,
+    files,
+    packages: spec.packages?.map(p => p.name) || [],
+    duration: Date.now() - startTime,
+  };
+
+  return result;
+}
+
+/**
+ * Detect framework and suggest a spec
+ */
+export async function detectAndSuggest(
+  projectRoot: string
+): Promise<ProjectSpec | null> {
+  const { readdir } = await import('fs/promises');
+  const { join } = await import('path');
+
+  try {
+    const entries = await readdir(projectRoot, { withFileTypes: true });
+    const files = entries.filter(e => e.isFile()).map(e => e.name);
+    const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+
+    // Detect Frappe
+    if (dirs.includes('sites') && dirs.includes('apps')) {
+      const appName = join(projectRoot).split('/').pop() || 'frappe-app';
+      return {
+        name: appName,
+        type: 'single-package',
+        frameworks: ['frappe'],
+        gitInit: true,
+      };
+    }
+
+    // Detect Next.js
+    if (files.includes('next.config.js') || files.includes('next.config.mjs')) {
+      return {
+        name: 'nextjs-app',
+        type: 'single-package',
+        frameworks: ['nextjs'],
+        features: { typescript: true, testing: true },
+        gitInit: true,
+      };
+    }
+
+    // Detect Node TypeScript
+    if (files.includes('package.json') && files.includes('tsconfig.json')) {
+      return {
+        name: 'node-app',
+        type: 'single-package',
+        frameworks: ['node', 'typescript'],
+        features: { typescript: true, testing: true, eslint: true },
+        gitInit: true,
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}