threadnote 1.7.0 → 1.7.1

package/config/post-update-migrations.json

@@ -25,15 +25,16 @@
       "title": "Consolidate memories under the git remote project name",
       "description": [
         "Threadnote now uses the git remote repository name as the default project identifier instead of the clone folder name.",
-        "This migration scans personal lifecycle-aware memory folders for the old folder-derived project name from the current workspace.",
-        "It also renames the matching seed manifest project and workset references so future seeded guidance uses the remote-derived project name.",
+        "This migration scans personal lifecycle-aware memory project folders and uses repo_path evidence in memories, plus matching seed manifest paths when present, to resolve git remote names.",
+        "It covers every detected personal memory project, not just the workspace where threadnote update was run.",
+        "It also renames matching seed manifest projects and workset references so future seeded guidance uses the remote-derived project name.",
         "Matching memories are copied under the remote-derived project name with updated project metadata, then the old copy is removed.",
         "If a destination file already exists with different content, Threadnote keeps both by writing the migrated copy with a -from-<old-project> suffix.",
-        "Shared team memories and unrelated project folders are left untouched."
+        "Shared team memories and projects without repo path evidence are left untouched."
       ],
       "commandArgs": ["migrate-project-names", "--apply"],
       "instructions": [
-        "Post-update project-name migration finished. Future default handoffs and memories for this repo will use the git remote repository name as their project.",
+        "Post-update project-name migration finished. Future default handoffs and memories for migrated repos will use the git remote repository name as their project.",
         "If the migration updated your seed manifest, run threadnote seed --only <new-project-name> to re-ingest seeded resources under the new project URI.",
         "If Threadnote reported any original files were still being processed, rerun the printed threadnote forget <uri> command later."
       ],

package/dist/threadnote.cjs

@@ -11633,21 +11633,30 @@ async function runMigrateLifecycle(config, options) {
 async function runMigrateProjectNames(config, options) {
   const dryRun = options.dryRun === true || options.apply !== true;
   const limit = options.limit ? parsePositiveInteger(options.limit, "project-name migration limit") : void 0;
-  const context = await projectNameMigrationContext();
-  if (!context) {
-    console.log("No git remote project-name change applies in the current workspace.");
+  const contexts = await projectNameMigrationContexts(config);
+  if (contexts.length === 0) {
+    console.log("No git remote project-name changes apply across configured projects.");
     return;
   }
-  const candidates = await projectNameMigrationCandidates(config, context, limit);
-  const seedManifestCandidate = await hasSeedManifestProjectNameMigrationCandidate(config, context);
-  if (candidates.length === 0 && !seedManifestCandidate) {
-    console.log(`No project-name migration candidates found for ${context.oldProject} -> ${context.newProject}.`);
+  const plans = [];
+  let remaining = limit;
+  for (const context of contexts) {
+    const candidates2 = remaining === 0 ? [] : await projectNameMigrationCandidates(config, context, remaining);
+    plans.push({ candidates: candidates2, context });
+    if (remaining !== void 0) {
+      remaining = Math.max(0, remaining - candidates2.length);
+    }
+  }
+  const seedManifestMigration = await seedManifestProjectNameMigration(config, contexts);
+  if (!plans.some((plan) => plan.candidates.length > 0) && !seedManifestMigration) {
+    console.log("No project-name migration candidates found across configured projects.");
     return;
   }
-  const seedManifestUpdated = await migrateSeedManifestProjectName(config, context, dryRun);
+  const seedManifestUpdated = await migrateSeedManifestProjectNames(config, seedManifestMigration, dryRun);
   let existingCount = 0;
   let migratedCount = 0;
   let skippedCount = 0;
+  const candidates = plans.flatMap((plan) => [...plan.candidates]);
   if (candidates.length > 0) {
     const ov = await openVikingCliForMode(dryRun);
     for (const candidate of candidates) {
@@ -11671,37 +11680,186 @@ async function runMigrateProjectNames(config, options) {
       migratedCount += 1;
     }
   }
+  const activeContexts = projectNameMigrationActiveContexts(plans, seedManifestMigration);
+  const newProjectsToSeed = [...new Set(seedManifestMigration?.newProjects ?? [])];
   console.log(
     [
-      `Project-name migration summary: ${migratedCount} memor${migratedCount === 1 ? "y" : "ies"} ${dryRun ? "would be migrated" : "migrated"} from ${context.oldProject} to ${context.newProject}`,
+      projectNameMigrationSummary(migratedCount, dryRun, activeContexts),
       seedManifestUpdated ? `seed manifest ${dryRun ? "would be updated" : "updated"}` : "seed manifest unchanged",
       `${existingCount} duplicate destination(s) reused`,
       `${skippedCount} source(s) still processing`,
       dryRun ? "Run with --apply to perform this migration." : void 0,
-      seedManifestUpdated ? `Run threadnote seed --only ${context.newProject} to re-ingest seeded resources under the new project URI.` : void 0
+      ...newProjectsToSeed.map(
+        (project) => `Run threadnote seed --only ${project} to re-ingest seeded resources under the new project URI.`
+      )
     ].filter((part) => part !== void 0).join("; ")
   );
 }
 async function hasProjectNameMigrationCandidates(config) {
-  const context = await projectNameMigrationContext();
-  return context ? (await projectNameMigrationCandidates(config, context, 1)).length > 0 || await hasSeedManifestProjectNameMigrationCandidate(config, context) : false;
+  const contexts = await projectNameMigrationContexts(config);
+  if (contexts.length === 0) {
+    return false;
+  }
+  for (const context of contexts) {
+    if ((await projectNameMigrationCandidates(config, context, 1)).length > 0) {
+      return true;
+    }
+  }
+  return await seedManifestProjectNameMigration(config, contexts) !== void 0;
+}
+async function projectNameMigrationContexts(config) {
+  const evidence = await projectNameMigrationMemoryEvidence(config);
+  const contexts = [];
+  let manifest;
+  try {
+    manifest = await readSeedManifest(config.manifestPath);
+  } catch (_err) {
+    manifest = void 0;
+  }
+  if (manifest) {
+    for (const project of manifest.projects) {
+      const projectEvidence = evidence.get(uriSegment(project.name));
+      if (projectEvidence) {
+        projectEvidence.repoPaths.add(expandPath(project.path));
+      }
+    }
+  }
+  for (const projectEvidence of evidence.values()) {
+    for (const repoPath of projectEvidence.repoPaths) {
+      const context = await projectNameMigrationContextForRepoPath(projectEvidence.oldProject, repoPath);
+      if (context) {
+        contexts.push(context);
+      }
+    }
+  }
+  const currentContext = await currentWorkspaceProjectNameMigrationContext(evidence);
+  if (currentContext) {
+    contexts.push(currentContext);
+  }
+  return dedupeProjectNameMigrationContexts(contexts);
+}
+async function projectNameMigrationMemoryEvidence(config) {
+  const evidence = /* @__PURE__ */ new Map();
+  for (const location of projectMemoryLocations()) {
+    const locationRoot = (0, import_node_path8.join)(localUserMemoriesRoot(config), ...location.relativePath);
+    let projectEntries;
+    try {
+      projectEntries = await (0, import_promises6.readdir)(locationRoot, { withFileTypes: true });
+    } catch (_err) {
+      continue;
+    }
+    for (const projectEntry of projectEntries) {
+      if (!projectEntry.isDirectory() || projectEntry.name.startsWith(".")) {
+        continue;
+      }
+      const oldSegment = projectEntry.name;
+      const projectEvidence = ensureProjectNameMigrationEvidence(evidence, oldSegment);
+      const projectDirectory = (0, import_node_path8.join)(locationRoot, projectEntry.name);
+      let memoryEntries;
+      try {
+        memoryEntries = await (0, import_promises6.readdir)(projectDirectory, { withFileTypes: true });
+      } catch (_err) {
+        continue;
+      }
+      for (const memoryEntry of memoryEntries) {
+        if (!memoryEntry.isFile() || memoryEntry.name.startsWith(".") || !memoryEntry.name.endsWith(".md")) {
+          continue;
+        }
+        const content = await readTextIfExists((0, import_node_path8.join)(projectDirectory, memoryEntry.name));
+        if (!content) {
+          continue;
+        }
+        const sourceUri = `viking://user/${uriSegment(config.user)}/memories/${location.uriPath}/${oldSegment}/${memoryEntry.name}`;
+        const record = parseMemoryDocument(sourceUri, content);
+        if (record?.metadata.project && uriSegment(record.metadata.project) === oldSegment) {
+          projectEvidence.oldProject = record.metadata.project;
+        }
+        const repoPath = repoPathEvidenceFromMemory(content);
+        if (repoPath) {
+          projectEvidence.repoPaths.add(repoPath);
+        }
+      }
+    }
+  }
+  return evidence;
+}
+function ensureProjectNameMigrationEvidence(evidence, oldSegment) {
+  const existing = evidence.get(oldSegment);
+  if (existing) {
+    return existing;
+  }
+  const created = { oldProject: oldSegment, oldSegment, repoPaths: /* @__PURE__ */ new Set() };
+  evidence.set(oldSegment, created);
+  return created;
+}
+function repoPathEvidenceFromMemory(content) {
+  const match = /^repo_path:\s*(.+)$/m.exec(content);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  const cleaned = match[1].trim().replace(/^['"`]+|['"`]+$/g, "").replace(/[.,;]+$/g, "");
+  if (!cleaned.startsWith("/") && !cleaned.startsWith("~/")) {
+    return void 0;
+  }
+  return expandPath(cleaned);
 }
-async function projectNameMigrationContext() {
+async function projectNameMigrationContextForRepoPath(oldProject, repoPath) {
+  const repoRoot = await gitValue(["rev-parse", "--show-toplevel"], repoPath);
+  if (!repoRoot) {
+    return void 0;
+  }
+  const newProject = await resolveGitRemoteRepoName(repoRoot);
+  if (!newProject) {
+    return void 0;
+  }
+  return projectNameMigrationContextFromParts({
+    newProject,
+    oldProject,
+    repoRoot
+  });
+}
+async function currentWorkspaceProjectNameMigrationContext(evidence) {
   const repoRoot = await gitValue(["rev-parse", "--show-toplevel"]);
   if (!repoRoot) {
     return void 0;
   }
-  const newProject = await resolveRepoName(repoRoot);
+  const newProject = await resolveGitRemoteRepoName(repoRoot);
   const oldProject = await resolveRepoFolderName(repoRoot);
   if (!newProject || !oldProject) {
     return void 0;
   }
-  const newSegment = uriSegment(newProject);
   const oldSegment = uriSegment(oldProject);
+  if (!evidence.has(oldSegment)) {
+    return void 0;
+  }
+  return projectNameMigrationContextFromParts({ newProject, oldProject, repoRoot });
+}
+function projectNameMigrationContextFromParts(params) {
+  const newSegment = uriSegment(params.newProject);
+  const oldSegment = uriSegment(params.oldProject);
   if (newSegment === oldSegment) {
     return void 0;
   }
-  return { newProject, newSegment, oldProject, oldSegment, repoRoot };
+  return {
+    newProject: params.newProject,
+    newSegment,
+    oldProject: params.oldProject,
+    oldSegment,
+    repoRoot: params.repoRoot
+  };
+}
+function dedupeProjectNameMigrationContexts(contexts) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const context of contexts) {
+    const key = `${context.oldSegment}\0${context.newSegment}\0${context.repoRoot}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(context);
+  }
+  return out;
 }
 async function projectNameMigrationCandidates(config, context, limit) {
   const candidates = [];
@@ -11753,11 +11911,23 @@ async function projectNameMigrationCandidates(config, context, limit) {
   }
   return candidates;
 }
-async function hasSeedManifestProjectNameMigrationCandidate(config, context) {
-  return await seedManifestProjectNameMigration(config, context) !== void 0;
+function projectNameMigrationActiveContexts(plans, seedManifestMigration) {
+  return dedupeProjectNameMigrationContexts([
+    ...plans.filter((plan) => plan.candidates.length > 0).map((plan) => plan.context),
+    ...seedManifestMigration?.contexts ?? []
+  ]);
 }
-async function migrateSeedManifestProjectName(config, context, dryRun) {
-  const migration = await seedManifestProjectNameMigration(config, context);
+function projectNameMigrationSummary(migratedCount, dryRun, contexts) {
+  const memoryWord = migratedCount === 1 ? "memory" : "memories";
+  const verb = dryRun ? "would be migrated" : "migrated";
+  if (contexts.length === 1) {
+    const [context] = contexts;
+    return `Project-name migration summary: ${migratedCount} ${memoryWord} ${verb} from ${context.oldProject} to ${context.newProject}`;
+  }
+  const renameSummary = contexts.map((context) => `${context.oldProject} -> ${context.newProject}`).join(", ");
+  return `Project-name migration summary: ${migratedCount} ${memoryWord} ${verb} across ${contexts.length} project rename(s)${renameSummary ? `: ${renameSummary}` : ""}`;
+}
+async function migrateSeedManifestProjectNames(config, migration, dryRun) {
   if (!migration) {
     return false;
   }
@@ -11779,33 +11949,45 @@ async function migrateSeedManifestProjectName(config, context, dryRun) {
   console.log(`Updated seed manifest: ${config.manifestPath}`);
   return true;
 }
-async function seedManifestProjectNameMigration(config, context) {
+async function seedManifestProjectNameMigration(config, contexts) {
   let manifest;
   try {
     manifest = await readSeedManifest(config.manifestPath);
   } catch (_err) {
     return void 0;
   }
-  const oldDefaultUri = `viking://resources/repos/${context.oldSegment}`;
-  const newDefaultUri = `viking://resources/repos/${context.newSegment}`;
-  const newNameExists = manifest.projects.some((project) => uriSegment(project.name) === context.newSegment);
+  const renamed = /* @__PURE__ */ new Map();
   let changed = false;
-  let renamedProject = false;
   const projects = manifest.projects.map((project) => {
-    if (!isSeedManifestProjectNameCandidate(project, context, oldDefaultUri) || newNameExists) {
+    const context = contexts.find(
+      (candidate) => isSeedManifestProjectNameCandidate(
+        project,
+        candidate,
+        `viking://resources/repos/${candidate.oldSegment}`,
+        `viking://resources/repos/${candidate.newSegment}`
+      )
+    );
+    if (!context) {
+      return project;
+    }
+    const newNameExists = manifest.projects.some(
+      (other) => other !== project && uriSegment(other.name) === context.newSegment
+    );
+    if (newNameExists || [...renamed.values()].some((existing) => existing.newSegment === context.newSegment)) {
       return project;
     }
     changed = true;
-    renamedProject = true;
+    renamed.set(context.oldSegment, context);
     return {
       ...project,
       name: context.newProject,
-      uri: trimTrailingSlash(project.uri) === oldDefaultUri ? newDefaultUri : project.uri
+      uri: trimTrailingSlash(project.uri) === `viking://resources/repos/${context.oldSegment}` ? `viking://resources/repos/${context.newSegment}` : project.uri
     };
   });
-  const worksets = renamedProject ? manifest.worksets?.map((workset) => {
+  const worksets = renamed.size > 0 ? manifest.worksets?.map((workset) => {
     const members = workset.projects.map((projectName) => {
-      if (uriSegment(projectName) !== context.oldSegment) {
+      const context = renamed.get(uriSegment(projectName));
+      if (!context) {
         return projectName;
       }
       changed = true;
@@ -11817,6 +11999,8 @@ async function seedManifestProjectNameMigration(config, context) {
     return void 0;
   }
   return {
+    contexts: [...renamed.values()],
+    newProjects: [...new Set([...renamed.values()].map((context) => context.newProject))],
     output: `${index_vite_proxy_tmp_default.dump(
       {
         version: manifest.version,
@@ -11844,11 +12028,17 @@ async function seedManifestProjectNameMigration(config, context) {
     )}`
   };
 }
-function isSeedManifestProjectNameCandidate(project, context, oldDefaultUri) {
-  if (uriSegment(project.name) !== context.oldSegment) {
+function isSeedManifestProjectNameCandidate(project, context, oldDefaultUri, newDefaultUri) {
+  const nameSegment = uriSegment(project.name);
+  const uriMatchesOld = trimTrailingSlash(project.uri) === oldDefaultUri;
+  const pathMatchesRepo = expandPath(project.path) === context.repoRoot;
+  if (nameSegment === context.newSegment && !uriMatchesOld) {
+    return false;
+  }
+  if (nameSegment !== context.oldSegment && !uriMatchesOld && !pathMatchesRepo) {
     return false;
   }
-  return trimTrailingSlash(project.uri) === oldDefaultUri || expandPath(project.path) === context.repoRoot;
+  return nameSegment !== context.newSegment || uriMatchesOld || trimTrailingSlash(project.uri) !== newDefaultUri;
 }
 function canMigrateProjectName(record, context) {
   const projectSegment = record.metadata.project ? uriSegment(record.metadata.project) : context.oldSegment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "threadnote",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "type": "commonjs",
   "main": "dist/threadnote.cjs",
   "description": "Shared local context and handoffs for development agents",