bonecode 1.0.0

package/bone/output/workspace/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "workspace_domain",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "migrate": "ts-node src/migrate.ts"
+  },
+  "dependencies": {
+    "express": "4.18.2",
+    "pg": "8.11.3",
+    "ioredis": "5.3.2",
+    "ws": "8.16.0",
+    "uuid": "9.0.0",
+    "cors": "2.8.5",
+    "helmet": "7.1.0",
+    "express-rate-limit": "7.1.5",
+    "jsonwebtoken": "9.0.2",
+    "dotenv": "16.3.1",
+    "node-cron": "3.0.3"
+  },
+  "devDependencies": {
+    "@types/express": "4.17.21",
+    "@types/node": "18.19.0",
+    "@types/pg": "8.10.9",
+    "@types/ws": "8.5.10",
+    "@types/cors": "2.8.17",
+    "@types/jsonwebtoken": "9.0.5",
+    "@types/uuid": "9.0.7",
+    "@types/node-cron": "3.0.11",
+    "typescript": "5.3.3",
+    "ts-node": "10.9.2"
+  }
+}

package/bone/output/workspace/schema.graphql

@@ -0,0 +1,153 @@
+# Generated by BoneScript compiler. DO NOT EDIT.
+# System: WorkspaceDomain v1.0.0
+
+type Workspace {
+  id: ID!
+  created_at: String!
+  updated_at: String!
+  project_id: ID!
+  root_path: String!
+  git_remote: String
+  git_branch: String
+  git_commit: String
+  is_dirty: Boolean!
+  file_count: Int
+  total_size_bytes: Int
+  config: String
+}
+
+type WorkspacePage {
+  items: [Workspace!]!
+  total: Int!
+  page: Int!
+  pageSize: Int!
+}
+
+input WorkspaceInput {
+  project_id: ID!
+  root_path: String!
+  git_remote: String
+  git_branch: String
+  git_commit: String
+  is_dirty: Boolean!
+  file_count: Int
+  total_size_bytes: Int
+  config: String
+}
+
+type Codebase {
+  id: ID!
+  created_at: String!
+  updated_at: String!
+  workspace_id: ID!
+  project_id: ID!
+  primary_language: String
+  languages: String
+  framework: String
+  build_tool: String
+  test_framework: String
+  entry_points: String
+  dependencies: String
+  analysis_version: String
+}
+
+type CodebasePage {
+  items: [Codebase!]!
+  total: Int!
+  page: Int!
+  pageSize: Int!
+}
+
+input CodebaseInput {
+  workspace_id: ID!
+  project_id: ID!
+  primary_language: String
+  languages: String
+  framework: String
+  build_tool: String
+  test_framework: String
+  entry_points: String
+  dependencies: String
+  analysis_version: String
+}
+
+type Snapshot {
+  id: ID!
+  created_at: String!
+  updated_at: String!
+  session_id: ID!
+  project_id: ID!
+  workspace_id: ID!
+  git_hash: String!
+  message_id: ID
+  part_id: ID
+  diff_summary: String
+  files_changed: Int
+}
+
+type SnapshotPage {
+  items: [Snapshot!]!
+  total: Int!
+  page: Int!
+  pageSize: Int!
+}
+
+input SnapshotInput {
+  session_id: ID!
+  project_id: ID!
+  workspace_id: ID!
+  git_hash: String!
+  message_id: ID
+  part_id: ID
+  diff_summary: String
+  files_changed: Int
+}
+
+type CapabilityResult {
+  ok: Boolean!
+  action: String!
+}
+
+input WorkspaceCreateSnapshotInput {
+  workspace: String!
+  session_id: ID!
+}
+
+input WorkspaceRevertToSnapshotInput {
+  workspace: String!
+  snapshot: String!
+}
+
+input WorkspaceAnalyzeCodebaseInput {
+  workspace: String!
+}
+
+input SnapshotRevertToSnapshotInput {
+  workspace: String!
+  snapshot: String!
+}
+
+type Query {
+  workspace(id: ID!): Workspace
+  workspaces(page: Int, pageSize: Int): WorkspacePage
+  codebase(id: ID!): Codebase
+  codebases(page: Int, pageSize: Int): CodebasePage
+  snapshot(id: ID!): Snapshot
+  snapshots(page: Int, pageSize: Int): SnapshotPage
+}
+
+type Mutation {
+  createWorkspace(input: WorkspaceInput!): Workspace!
+  updateWorkspace(id: ID!, input: WorkspaceInput!): Workspace!
+  deleteWorkspace(id: ID!): Boolean!
+  createSnapshot(input: WorkspaceCreateSnapshotInput): CapabilityResult!
+  revertToSnapshot(input: WorkspaceRevertToSnapshotInput): CapabilityResult!
+  analyzeCodebase(input: WorkspaceAnalyzeCodebaseInput): CapabilityResult!
+  createCodebase(input: CodebaseInput!): Codebase!
+  updateCodebase(id: ID!, input: CodebaseInput!): Codebase!
+  deleteCodebase(id: ID!): Boolean!
+  createSnapshot(input: SnapshotInput!): Snapshot!
+  updateSnapshot(id: ID!, input: SnapshotInput!): Snapshot!
+  deleteSnapshot(id: ID!): Boolean!
+  revertToSnapshot(input: SnapshotRevertToSnapshotInput): CapabilityResult!
+}

package/bone/output/workspace/sdk/client.ts

@@ -0,0 +1,155 @@
+// Generated by BoneScript compiler. Import this file into your frontend.
+// System: WorkspaceDomain v1.0.0
+
+export interface Workspace {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  project_id: string;
+  root_path: string;
+  git_remote: string | null | null;
+  git_branch: string | null | null;
+  git_commit: string | null | null;
+  is_dirty: boolean;
+  file_count: number | null | null;
+  total_size_bytes: number | null | null;
+  config: unknown | null | null;
+}
+
+export interface Codebase {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  workspace_id: string;
+  project_id: string;
+  primary_language: string | null | null;
+  languages: unknown | null | null;
+  framework: string | null | null;
+  build_tool: string | null | null;
+  test_framework: string | null | null;
+  entry_points: unknown | null | null;
+  dependencies: unknown | null | null;
+  analysis_version: string | null | null;
+}
+
+export interface Snapshot {
+  id: string;
+  created_at: string;
+  updated_at: string;
+  session_id: string;
+  project_id: string;
+  workspace_id: string;
+  git_hash: string;
+  message_id: string | null | null;
+  part_id: string | null | null;
+  diff_summary: unknown | null | null;
+  files_changed: number | null | null;
+}
+
+export class WorkspaceDomainClient {
+  constructor(private baseUrl: string, private getToken?: () => string | null) {}
+
+  private async request<T>(method: string, path: string, body?: unknown): Promise<T> {
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+    if (this.getToken) {
+      const token = this.getToken();
+      if (token) headers["Authorization"] = "Bearer " + token;
+    }
+    const res = await fetch(this.baseUrl + path, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => res.statusText);
+      throw new Error(`HTTP ${res.status}: ${text}`);
+    }
+    if (res.status === 204) return undefined as unknown as T;
+    return res.json() as Promise<T>;
+  }
+
+  // ─── Workspace ───
+
+  listWorkspace(page = 1, pageSize = 50): Promise<{ items: Workspace[]; total: number; page: number; page_size: number }> {
+    return this.request("GET", `/workspaces?page=${page}&page_size=${pageSize}`);
+  }
+
+  getWorkspace(id: string): Promise<Workspace> {
+    return this.request("GET", `/workspaces/${id}`);
+  }
+
+  createWorkspace(data: Partial<Workspace>): Promise<Workspace> {
+    return this.request("POST", "/workspaces", data);
+  }
+
+  updateWorkspace(id: string, data: Partial<Workspace>): Promise<Workspace> {
+    return this.request("PUT", `/workspaces/${id}`, data);
+  }
+
+  deleteWorkspace(id: string): Promise<void> {
+    return this.request("DELETE", `/workspaces/${id}`);
+  }
+
+  createSnapshot(data: Record<string, unknown>): Promise<{ ok: boolean; action: string }> {
+    return this.request("POST", "/workspaces/create-snapshot", data);
+  }
+
+  revertToSnapshot(data: Record<string, unknown>): Promise<{ ok: boolean; action: string }> {
+    return this.request("POST", "/workspaces/revert-to-snapshot", data);
+  }
+
+  analyzeCodebase(data: Record<string, unknown>): Promise<{ ok: boolean; action: string }> {
+    return this.request("POST", "/workspaces/analyze-codebase", data);
+  }
+
+  // ─── Codebase ───
+
+  listCodebase(page = 1, pageSize = 50): Promise<{ items: Codebase[]; total: number; page: number; page_size: number }> {
+    return this.request("GET", `/codebases?page=${page}&page_size=${pageSize}`);
+  }
+
+  getCodebase(id: string): Promise<Codebase> {
+    return this.request("GET", `/codebases/${id}`);
+  }
+
+  createCodebase(data: Partial<Codebase>): Promise<Codebase> {
+    return this.request("POST", "/codebases", data);
+  }
+
+  updateCodebase(id: string, data: Partial<Codebase>): Promise<Codebase> {
+    return this.request("PUT", `/codebases/${id}`, data);
+  }
+
+  deleteCodebase(id: string): Promise<void> {
+    return this.request("DELETE", `/codebases/${id}`);
+  }
+
+  // ─── Snapshot ───
+
+  listSnapshot(page = 1, pageSize = 50): Promise<{ items: Snapshot[]; total: number; page: number; page_size: number }> {
+    return this.request("GET", `/snapshots?page=${page}&page_size=${pageSize}`);
+  }
+
+  getSnapshot(id: string): Promise<Snapshot> {
+    return this.request("GET", `/snapshots/${id}`);
+  }
+
+  createSnapshot(data: Partial<Snapshot>): Promise<Snapshot> {
+    return this.request("POST", "/snapshots", data);
+  }
+
+  updateSnapshot(id: string, data: Partial<Snapshot>): Promise<Snapshot> {
+    return this.request("PUT", `/snapshots/${id}`, data);
+  }
+
+  deleteSnapshot(id: string): Promise<void> {
+    return this.request("DELETE", `/snapshots/${id}`);
+  }
+
+  revertToSnapshot(data: Record<string, unknown>): Promise<{ ok: boolean; action: string }> {
+    return this.request("POST", "/snapshots/revert-to-snapshot", data);
+  }
+
+}

package/bone/output/workspace/src/algorithms.ts

@@ -0,0 +1,2 @@
+// No algorithms used in this system.
+export {};

package/bone/output/workspace/src/audit.ts

@@ -0,0 +1,37 @@
+// Generated by BoneScript compiler.
+// Audit middleware for: WorkspaceDomain v1.0.0
+
+import { Request, Response, NextFunction } from "express";
+import { query } from "./db";
+
+export function auditLog(action: string, entityType?: string) {
+  return async (req: Request, _res: Response, next: NextFunction): Promise<void> => {
+    try {
+      const auth = (req as any).auth as { actor_id?: string | null } | undefined;
+      const actorId = auth?.actor_id ?? null;
+      const entityId = req.params.id ?? (req.body as Record<string, unknown>)?.id ?? null;
+      const payload = req.body ?? null;
+      const ipAddress = req.ip ?? null;
+      const userAgent = req.headers["user-agent"] ?? null;
+
+      await query(
+        `INSERT INTO audit_log
+          (actor_id, action, entity_type, entity_id, payload, ip_address, user_agent)
+          VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+        [actorId, action, entityType ?? null, entityId, JSON.stringify(payload), ipAddress, userAgent]
+      );
+    } catch (err) {
+      // Audit failures must not block the request — log and continue
+      console.error("[audit] Failed to write audit log:", err);
+    }
+    next();
+  };
+}
+
+export async function getAuditLog(entityType: string, entityId: string): Promise<any[]> {
+  const result = await query(
+    "SELECT * FROM audit_log WHERE entity_type = $1 AND entity_id = $2 ORDER BY created_at DESC LIMIT 100",
+    [entityType, entityId]
+  );
+  return result.rows;
+}

package/bone/output/workspace/src/auth.ts

@@ -0,0 +1,57 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+import { Request, Response, NextFunction } from "express";
+import jwt from "jsonwebtoken";
+
+// JWT_SECRET must be set in production. The server will refuse to start without it
+// when NODE_ENV is "production" to prevent accidental use of a weak fallback.
+const JWT_SECRET = (() => {
+  const secret = process.env.JWT_SECRET;
+  if (!secret) {
+    if (process.env.NODE_ENV === "production") {
+      console.error("[FATAL] JWT_SECRET environment variable is not set. Refusing to start in production.");
+      process.exit(1);
+    }
+    console.warn("[WARN] JWT_SECRET is not set. Using insecure default — do not use in production.");
+    return "bonescript-dev-secret-do-not-use-in-production";
+  }
+  if (secret.length < 32) {
+    console.warn("[WARN] JWT_SECRET is shorter than 32 characters. Use a longer secret in production.");
+  }
+  return secret;
+})();
+
+export interface AuthContext {
+  authenticated: boolean;
+  actor_id: string | null;
+  trace_id: string;
+}
+
+export function authMiddleware(req: Request, res: Response, next: NextFunction): void {
+  const header = req.headers.authorization;
+  if (!header || !header.startsWith("Bearer ")) {
+    (req as any).auth = { authenticated: false, actor_id: null, trace_id: req.headers["x-trace-id"] as string || "" };
+    next();
+    return;
+  }
+  try {
+    const token = header.slice(7);
+    const decoded = jwt.verify(token, JWT_SECRET) as { sub: string };
+    (req as any).auth = {
+      authenticated: true,
+      actor_id: decoded.sub,
+      trace_id: req.headers["x-trace-id"] as string || "",
+    };
+  } catch {
+    (req as any).auth = { authenticated: false, actor_id: null, trace_id: req.headers["x-trace-id"] as string || "" };
+  }
+  next();
+}
+
+export function requireAuth(req: Request, res: Response, next: NextFunction): void {
+  const auth: AuthContext = (req as any).auth;
+  if (!auth || !auth.authenticated) {
+    res.status(401).json({ error: { code: "UNAUTHORIZED", message: "Authentication required" } });
+    return;
+  }
+  next();
+}

package/bone/output/workspace/src/cron.ts

@@ -0,0 +1,12 @@
+// Generated by BoneScript compiler.
+// Cron jobs — scheduled background tasks.
+// Uncomment and configure as needed.
+
+import cron from "node-cron";
+import { logger } from "./logger";
+
+export function startCronJobs(): void {
+  logger.info("cron_started", { event: "startup" });
+
+  // No batch capabilities declared — add cron jobs here.
+}

package/bone/output/workspace/src/db.ts

@@ -0,0 +1,32 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+import { Pool, PoolClient } from "pg";
+
+// Lazy pool — created on first use so DATABASE_URL is read after dotenv loads
+let _pool: Pool | null = null;
+function getPool(): Pool {
+  if (!_pool) {
+  _pool = new Pool({ connectionString: process.env.DATABASE_URL || "postgresql://localhost:5432/workspace_domain", max: 20 });
+  _pool.on("error", (err: Error) => console.error("[DB] Pool error (non-fatal):", err.message));
+  }
+  return _pool;
+}
+export const pool = new Proxy({} as Pool, { get(_t: any, p: any) { return (getPool() as any)[p]; } });
+
+export async function query<T = any>(text: string, params?: any[]): Promise<T[]> {
+  try { const result = await pool.query(text, params); return result.rows as T[]; }
+  catch (e: any) { throw new Error(`DB query failed: ${e.message}`); }
+}
+export async function queryOne<T = any>(text: string, params?: any[]): Promise<T | null> {
+  try { const rows = await query<T>(text, params); return rows[0] || null; }
+  catch (e: any) { throw new Error(`DB query failed: ${e.message}`); }
+}
+export async function execute(text: string, params?: any[]): Promise<number> {
+  try { const result = await pool.query(text, params); return result.rowCount || 0; }
+  catch (e: any) { throw new Error(`DB execute failed: ${e.message}`); }
+}
+export async function transaction<T>(fn: (client: PoolClient) => Promise<T>): Promise<T> {
+  const client = await pool.connect();
+  try { await client.query("BEGIN"); const result = await fn(client); await client.query("COMMIT"); return result; }
+  catch (e) { await client.query("ROLLBACK"); throw e; }
+  finally { client.release(); }
+}

package/bone/output/workspace/src/debug.ts

@@ -0,0 +1,66 @@
+// Generated by BoneScript compiler. DO NOT EDIT.
+// Runtime error handler with .bone source annotation.
+
+import * as fs from "fs";
+import * as path from "path";
+
+interface BoneMapping {
+  generated_file: string;
+  generated_line: number;
+  bone_line: number;
+  bone_column: number;
+  description: string;
+}
+
+interface BoneSourceMap {
+  version: number;
+  source_hash: string;
+  source_file: string;
+  mappings: BoneMapping[];
+}
+
+let sourceMap: BoneSourceMap | null = null;
+
+function loadSourceMap(): BoneSourceMap | null {
+  if (sourceMap) return sourceMap;
+  const mapPath = path.join(__dirname, "..", "WorkspaceDomain.bone.map");
+  if (!fs.existsSync(mapPath)) return null;
+  try {
+    sourceMap = JSON.parse(fs.readFileSync(mapPath, "utf-8"));
+    return sourceMap;
+  } catch {
+    return null;
+  }
+}
+
+export function annotateBoneError(err: Error, generatedFile: string): string {
+  const map = loadSourceMap();
+  if (!map) return err.stack || err.message;
+
+  // Extract line number from stack trace
+  const lineMatch = err.stack?.match(new RegExp(generatedFile.replace(/[/\\]/g, "[/\\\\]") + ":(\\d+)"));
+  if (!lineMatch) return err.stack || err.message;
+
+  const generatedLine = parseInt(lineMatch[1], 10);
+  const mapping = map.mappings
+    .filter(m => m.generated_file.includes(generatedFile) && m.generated_line <= generatedLine)
+    .sort((a, b) => b.generated_line - a.generated_line)[0];
+
+  if (!mapping) return err.stack || err.message;
+
+  return [
+    `BoneScript source: ${map.source_file}:${mapping.bone_line}:${mapping.bone_column}`,
+    `  Context: ${mapping.description}`,
+    `Generated TS: ${generatedFile}:${generatedLine}`,
+    ``,
+    err.stack || err.message,
+  ].join("\n");
+}
+
+// Global error handler — annotates unhandled errors with .bone context
+process.on("uncaughtException", (err: Error) => {
+  const annotated = annotateBoneError(err, err.stack?.split("\n")[1]?.match(/\((.+):\d+:\d+\)/)?.[1] || "");
+  console.error("[BoneScript] Unhandled error:");
+  console.error(annotated);
+  // process.exit(1); // disabled - errors should not crash the server
+});