@aprovan/hardcopy 0.1.0

package/src/formats/github-issue.ts

@@ -0,0 +1,55 @@
+import type { FormatHandler, ParsedFile } from "../format";
+import type { Node } from "../types";
+import matter from "gray-matter";
+
+export const githubIssueFormat: FormatHandler = {
+  type: "github.Issue",
+  editableFields: ["title", "body", "labels", "assignee", "milestone", "state"],
+
+  render(node: Node): string {
+    const attrs = node.attrs as Record<string, unknown>;
+    const frontmatter: Record<string, unknown> = {
+      _type: "github.Issue",
+      _id: node.id,
+    };
+
+    const addIfDefined = (key: string, value: unknown) => {
+      if (value !== undefined && value !== null) {
+        frontmatter[key] = value;
+      }
+    };
+
+    addIfDefined("number", attrs["number"]);
+    addIfDefined("title", attrs["title"]);
+    addIfDefined("state", attrs["state"]);
+    addIfDefined("url", attrs["url"]);
+    addIfDefined("labels", attrs["labels"]);
+    addIfDefined("assignee", attrs["assignee"]);
+    addIfDefined("milestone", attrs["milestone"]);
+    addIfDefined("created_at", attrs["created_at"]);
+    addIfDefined("updated_at", attrs["updated_at"]);
+    
+    if (attrs["syncedAt"]) {
+      frontmatter["_synced"] = new Date(attrs["syncedAt"] as number).toISOString();
+    }
+
+    const body = (attrs["body"] as string) ?? "";
+    return matter.stringify(body, frontmatter);
+  },
+
+  parse(content: string): ParsedFile {
+    const { data, content: body } = matter(content);
+    const attrs: Record<string, unknown> = {};
+
+    if (data["title"]) attrs["title"] = data["title"];
+    if (data["state"]) attrs["state"] = data["state"];
+    if (data["labels"]) attrs["labels"] = data["labels"];
+    if (data["assignee"]) attrs["assignee"] = data["assignee"];
+    if (data["milestone"]) attrs["milestone"] = data["milestone"];
+
+    return {
+      attrs,
+      body: body.trim(),
+    };
+  },
+};

package/src/hardcopy/core.ts

@@ -0,0 +1,78 @@
+import { join } from "path";
+import { mkdir } from "fs/promises";
+import { Database } from "../db";
+import { CRDTStore } from "../crdt";
+import { ConflictStore } from "../conflict-store";
+import { loadEnvFile } from "../env";
+import { loadConfig, type Config } from "../config";
+import { getProvider, type Provider } from "../provider";
+import type { HardcopyOptions } from "./types";
+
+export class Hardcopy {
+  readonly root: string;
+  readonly dataDir: string;
+  private _db: Database | null = null;
+  private _crdt: CRDTStore | null = null;
+  private _config: Config | null = null;
+  private _providers = new Map<string, Provider>();
+  private _conflictStore: ConflictStore | null = null;
+
+  constructor(options: HardcopyOptions) {
+    this.root = options.root;
+    this.dataDir = join(options.root, ".hardcopy");
+  }
+
+  async initialize(): Promise<void> {
+    await mkdir(this.dataDir, { recursive: true });
+    await loadEnvFile(join(this.dataDir, ".env"));
+    await mkdir(join(this.dataDir, "crdt"), { recursive: true });
+    this._db = await Database.open(join(this.dataDir, "db.sqlite"));
+    this._crdt = new CRDTStore(join(this.dataDir, "crdt"));
+  }
+
+  async loadConfig(): Promise<Config> {
+    if (this._config) return this._config;
+    const configPath = join(this.root, "hardcopy.yaml");
+    this._config = await loadConfig(configPath);
+    await this.initializeProviders();
+    return this._config;
+  }
+
+  private async initializeProviders(): Promise<void> {
+    if (!this._config) return;
+    for (const source of this._config.sources) {
+      const factory = getProvider(source.provider);
+      if (factory) {
+        this._providers.set(source.name, factory(source));
+      }
+    }
+  }
+
+  getDatabase(): Database {
+    if (!this._db) throw new Error("Database not initialized");
+    return this._db;
+  }
+
+  getCRDTStore(): CRDTStore {
+    if (!this._crdt) throw new Error("CRDT store not initialized");
+    return this._crdt;
+  }
+
+  getConflictStore(): ConflictStore {
+    if (!this._conflictStore) {
+      this._conflictStore = new ConflictStore(join(this.dataDir, "conflicts"));
+    }
+    return this._conflictStore;
+  }
+
+  getProviders(): Map<string, Provider> {
+    return this._providers;
+  }
+
+  async close(): Promise<void> {
+    if (this._db) {
+      await this._db.close();
+      this._db = null;
+    }
+  }
+}

package/src/hardcopy/diff.ts

@@ -0,0 +1,188 @@
+import { join } from "path";
+import { readFile, stat } from "fs/promises";
+import { minimatch } from "minimatch";
+import { parseFile, getFormat } from "../format";
+import type { Node, Change } from "../types";
+import type { Hardcopy } from "./core";
+import type { DiffResult, ChangedFile } from "./types";
+import { listViewFiles } from "./views";
+
+export async function getChangedFiles(
+  this: Hardcopy,
+  pattern?: string,
+): Promise<ChangedFile[]> {
+  const config = await this.loadConfig();
+  const db = this.getDatabase();
+  const changedFiles: ChangedFile[] = [];
+
+  for (const view of config.views) {
+    const viewDir = join(this.root, view.path);
+    const files = await listViewFiles(viewDir);
+
+    for (const relPath of files) {
+      const fullPath = join(viewDir, relPath);
+      const viewRelPath = join(view.path, relPath);
+
+      if (
+        pattern &&
+        !minimatch(viewRelPath, pattern) &&
+        !viewRelPath.startsWith(pattern)
+      ) {
+        continue;
+      }
+
+      const fileStat = await stat(fullPath).catch(() => null);
+      if (!fileStat) continue;
+
+      const content = await readFile(fullPath, "utf-8");
+      const parsed = parseFile(content, "generic");
+      const nodeId = (parsed.attrs._id ?? parsed.attrs.id) as
+        | string
+        | undefined;
+      if (!nodeId) continue;
+
+      const dbNode = await db.getNode(nodeId);
+      const fileMtime = fileStat.mtimeMs;
+      const syncedAt = dbNode?.syncedAt ?? 0;
+
+      if (fileMtime > syncedAt) {
+        changedFiles.push({
+          path: viewRelPath,
+          fullPath,
+          nodeId,
+          nodeType:
+            dbNode?.type ?? (parsed.attrs._type as string) ?? "unknown",
+          status: dbNode ? "modified" : "new",
+          mtime: fileMtime,
+          syncedAt,
+        });
+      }
+    }
+  }
+
+  return changedFiles;
+}
+
+export async function diff(
+  this: Hardcopy,
+  pattern?: string,
+  options: { smart?: boolean } = {},
+): Promise<DiffResult[]> {
+  const config = await this.loadConfig();
+  const db = this.getDatabase();
+  const results: DiffResult[] = [];
+
+  const useSmart = options.smart !== false;
+
+  if (useSmart && pattern) {
+    const candidates = await getChangedFiles.call(this, pattern);
+    for (const candidate of candidates) {
+      const result = await diffFile.call(this, candidate.fullPath, db);
+      if (result && result.changes.length > 0) {
+        results.push(result);
+      }
+    }
+    return results;
+  }
+
+  for (const view of config.views) {
+    const viewDir = join(this.root, view.path);
+    const files = await listViewFiles(viewDir);
+
+    for (const relPath of files) {
+      const fullPath = join(viewDir, relPath);
+      const viewRelPath = join(view.path, relPath);
+
+      if (pattern) {
+        const targetPath = join(this.root, pattern);
+        const isExactMatch = fullPath === targetPath;
+        const isGlobMatch = minimatch(viewRelPath, pattern);
+        const isPrefixMatch = viewRelPath.startsWith(pattern);
+        if (!isExactMatch && !isGlobMatch && !isPrefixMatch) continue;
+      }
+
+      const result = await diffFile.call(this, fullPath, db);
+      if (result && result.changes.length > 0) {
+        results.push(result);
+      }
+    }
+  }
+
+  return results;
+}
+
+async function diffFile(
+  this: Hardcopy,
+  fullPath: string,
+  db: ReturnType<Hardcopy["getDatabase"]>,
+): Promise<DiffResult | null> {
+  try {
+    const content = await readFile(fullPath, "utf-8");
+    const parsed = parseFile(content, "generic");
+
+    const nodeId = (parsed.attrs._id ?? parsed.attrs.id) as string | undefined;
+    const nodeType = parsed.attrs._type as string | undefined;
+    if (!nodeId) return null;
+
+    const dbNode = await db.getNode(nodeId);
+    if (!dbNode) {
+      return {
+        nodeId,
+        nodeType: nodeType ?? "unknown",
+        filePath: fullPath,
+        changes: [{ field: "_new", oldValue: null, newValue: parsed.attrs }],
+      };
+    }
+
+    const format = getFormat(dbNode.type);
+    if (!format) return null;
+
+    const changes = detectChanges(parsed, dbNode, format.editableFields);
+    return {
+      nodeId,
+      nodeType: dbNode.type,
+      filePath: fullPath,
+      changes,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function detectChanges(
+  parsed: { attrs: Record<string, unknown>; body: string },
+  dbNode: Node,
+  editableFields: string[],
+): Change[] {
+  const changes: Change[] = [];
+  const dbAttrs = dbNode.attrs as Record<string, unknown>;
+
+  for (const field of editableFields) {
+    if (field === "body") {
+      const oldBody = ((dbAttrs["body"] as string) ?? "").trim();
+      const newBody = parsed.body.trim();
+      if (newBody !== oldBody) {
+        changes.push({ field: "body", oldValue: oldBody, newValue: newBody });
+      }
+    } else {
+      const oldValue = dbAttrs[field];
+      const newValue = parsed.attrs[field];
+      if (!valuesEqual(oldValue, newValue)) {
+        changes.push({ field, oldValue, newValue });
+      }
+    }
+  }
+
+  return changes;
+}
+
+function valuesEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a == null && b == null) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return (
+      a.length === b.length && a.every((v, i) => valuesEqual(v, b[i]))
+    );
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}

package/src/hardcopy/index.ts

@@ -0,0 +1,67 @@
+import { registerFormat } from "../format";
+import { githubIssueFormat } from "../formats/github-issue";
+import "../providers";
+
+import { Hardcopy } from "./core";
+import { sync } from "./sync";
+import { getViews, refreshView } from "./views";
+import { diff, getChangedFiles } from "./diff";
+import {
+  push,
+  status,
+  listConflicts,
+  getConflict,
+  getConflictDetail,
+  resolveConflict,
+} from "./push";
+
+registerFormat(githubIssueFormat);
+
+// Extend Hardcopy prototype with operation methods
+declare module "./core" {
+  interface Hardcopy {
+    sync(): Promise<import("./types").SyncStats>;
+    getViews(): Promise<string[]>;
+    refreshView(
+      viewPath: string,
+      options?: { clean?: boolean },
+    ): Promise<import("./types").RefreshResult>;
+    diff(
+      pattern?: string,
+      options?: { smart?: boolean },
+    ): Promise<import("./types").DiffResult[]>;
+    getChangedFiles(pattern?: string): Promise<import("./types").ChangedFile[]>;
+    push(
+      filePath?: string,
+      options?: { force?: boolean },
+    ): Promise<import("./types").PushStats>;
+    status(): Promise<import("./types").StatusInfo>;
+    listConflicts(): Promise<import("../types").ConflictInfo[]>;
+    getConflict(nodeId: string): Promise<import("../types").ConflictInfo | null>;
+    getConflictDetail(nodeId: string): Promise<{
+      info: import("../types").ConflictInfo;
+      body: string;
+      artifactPath: string;
+    } | null>;
+    resolveConflict(
+      nodeId: string,
+      resolution: Record<string, "local" | "remote">,
+    ): Promise<void>;
+  }
+}
+
+Hardcopy.prototype.sync = sync;
+Hardcopy.prototype.getViews = getViews;
+Hardcopy.prototype.refreshView = refreshView;
+Hardcopy.prototype.diff = diff;
+Hardcopy.prototype.getChangedFiles = getChangedFiles;
+Hardcopy.prototype.push = push;
+Hardcopy.prototype.status = status;
+Hardcopy.prototype.listConflicts = listConflicts;
+Hardcopy.prototype.getConflict = getConflict;
+Hardcopy.prototype.getConflictDetail = getConflictDetail;
+Hardcopy.prototype.resolveConflict = resolveConflict;
+
+export { Hardcopy } from "./core";
+export { initHardcopy } from "./init";
+export * from "./types";

package/src/hardcopy/init.ts

@@ -0,0 +1,24 @@
+import { join } from "path";
+import { mkdir, writeFile, access } from "fs/promises";
+import { Database } from "../db";
+
+export async function initHardcopy(root: string): Promise<void> {
+  const dataDir = join(root, ".hardcopy");
+  await mkdir(dataDir, { recursive: true });
+  await mkdir(join(dataDir, "crdt"), { recursive: true });
+  await mkdir(join(dataDir, "errors"), { recursive: true });
+
+  const db = await Database.open(join(dataDir, "db.sqlite"));
+  await db.close();
+
+  const configPath = join(root, "hardcopy.yaml");
+  try {
+    await access(configPath);
+  } catch {
+    const defaultConfig = `# Hardcopy configuration
+sources: []
+views: []
+`;
+    await writeFile(configPath, defaultConfig);
+  }
+}