reffy-cli 0.7.0 → 1.1.1

package/dist/storage.js

@@ -198,6 +198,56 @@ export class ReferencesStore {
     async validateManifest() {
         return validateManifest(this.manifestPath, this.artifactsDir);
     }
+    async linkPlanningOutputs(artifactFilenames, outputPaths, changeId) {
+        const manifest = await this.readManifest();
+        const targets = new Set(artifactFilenames);
+        let linked = 0;
+        for (const artifact of manifest.artifacts) {
+            if (!targets.has(artifact.filename))
+                continue;
+            artifact.related_changes = Array.from(new Set([...(artifact.related_changes ?? []), changeId]));
+            artifact.derived_outputs = Array.from(new Set([...(artifact.derived_outputs ?? []), ...outputPaths]));
+            artifact.updated_at = utcNow();
+            linked += 1;
+        }
+        if (linked > 0) {
+            manifest.updated_at = utcNow();
+            await this.writeManifest(manifest);
+        }
+        return { linked };
+    }
+    async rewriteDerivedOutputPaths(pathMap) {
+        const replacements = Object.entries(pathMap);
+        if (replacements.length === 0) {
+            return { updated: 0 };
+        }
+        const manifest = await this.readManifest();
+        let updated = 0;
+        for (const artifact of manifest.artifacts) {
+            const outputs = artifact.derived_outputs ?? [];
+            if (outputs.length === 0)
+                continue;
+            let changed = false;
+            const nextOutputs = outputs.map((outputPath) => {
+                const replacement = pathMap[outputPath];
+                if (!replacement || replacement === outputPath) {
+                    return outputPath;
+                }
+                changed = true;
+                return replacement;
+            });
+            if (!changed)
+                continue;
+            artifact.derived_outputs = Array.from(new Set(nextOutputs));
+            artifact.updated_at = utcNow();
+            updated += 1;
+        }
+        if (updated > 0) {
+            manifest.updated_at = utcNow();
+            await this.writeManifest(manifest);
+        }
+        return { updated };
+    }
     async updateArtifact(artifactId, input) {
         const manifest = await this.readManifest();
         const index = manifest.artifacts.findIndex((item) => item.id === artifactId);

package/dist/types.d.ts

@@ -6,6 +6,9 @@ export interface Artifact {
     mime_type: string;
     size_bytes: number;
     tags: string[];
+    status?: string;
+    related_changes?: string[];
+    derived_outputs?: string[];
     created_at: string;
     updated_at: string;
 }

package/dist/workspace.d.ts

@@ -0,0 +1,8 @@
+import { type WorkspaceState } from "./refs-paths.js";
+export interface WorkspacePreparationResult {
+    state: WorkspaceState;
+    migrated: boolean;
+    created: boolean;
+    message?: string;
+}
+export declare function prepareCanonicalWorkspace(repoRoot: string): Promise<WorkspacePreparationResult>;

package/dist/workspace.js

@@ -0,0 +1,51 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { DEFAULT_REFS_DIRNAME, LEGACY_REFS_DIRNAME, detectWorkspaceState, resolveCanonicalRefsDir, } from "./refs-paths.js";
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureCanonicalStructure(repoRoot) {
+    const refsDir = resolveCanonicalRefsDir(repoRoot);
+    const artifactsDir = path.join(refsDir, "artifacts");
+    const manifestPath = path.join(refsDir, "manifest.json");
+    let created = false;
+    if (!(await pathExists(refsDir))) {
+        created = true;
+    }
+    await fs.mkdir(artifactsDir, { recursive: true });
+    if (!(await pathExists(manifestPath))) {
+        const now = new Date().toISOString();
+        await fs.writeFile(manifestPath, JSON.stringify({
+            version: 1,
+            created_at: now,
+            updated_at: now,
+            artifacts: [],
+        }, null, 2), "utf8");
+    }
+    return created;
+}
+export async function prepareCanonicalWorkspace(repoRoot) {
+    const current = detectWorkspaceState(repoRoot);
+    if (current.mode === "legacy") {
+        await fs.rename(current.legacyDir, current.canonicalDir);
+        const state = detectWorkspaceState(repoRoot);
+        return {
+            state,
+            migrated: true,
+            created: false,
+            message: `Migrated ${LEGACY_REFS_DIRNAME}/ to ${DEFAULT_REFS_DIRNAME}/`,
+        };
+    }
+    const created = await ensureCanonicalStructure(repoRoot);
+    return {
+        state: detectWorkspaceState(repoRoot),
+        migrated: false,
+        created,
+    };
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "reffy-cli",
-  "version": "0.7.0",
+  "version": "1.1.1",
   "description": "CLI-first, framework-agnostic references workflow for any repo (TypeScript)",
   "keywords": [
     "reffy",
-    "openspec",
+    "reffyspec",
     "specs",
     "cli",
     "ai",
@@ -12,6 +12,14 @@
     "sdd"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RoskiDeluge/reffy.git"
+  },
+  "homepage": "https://github.com/RoskiDeluge/reffy",
+  "bugs": {
+    "url": "https://github.com/RoskiDeluge/reffy/issues"
+  },
   "type": "module",
   "main": "dist/index.js",
   "files": [
@@ -33,6 +41,10 @@
   "engines": {
     "node": ">=20"
   },
+  "publishConfig": {
+    "provenance": true,
+    "access": "public"
+  },
   "dependencies": {
     "beautiful-mermaid": "^0.1.3",
     "mime-types": "^2.1.35",