@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.5

package/src/runtime/scaffold/{languages.ts → languages.js}

@@ -10,7 +10,7 @@
  * repository itself uses (for test stubs, which have no file extension of their own to read).
  */
 
-const { detectCommands } = require('../command-detect.ts');
+const { detectCommands } = require('../command-detect.js');
 
 /**
  * Per-file language comes from the file's own extension, because `plan.md` already states it:
@@ -22,7 +22,7 @@ const { detectCommands } = require('../command-detect.ts');
  * is this repository" — is `command-detect.ts`'s, so it is asked there rather than answered a
  * second time here. See `repoLanguage()` for the one place its output is interpreted.
  */
-const EXTENSION_LANGUAGE: Readonly<Record<string, string>> = Object.freeze({
+const EXTENSION_LANGUAGE                                   = Object.freeze({
   '.js': 'javascript',
   '.mjs': 'javascript',
   '.cjs': 'javascript',
@@ -41,7 +41,7 @@ const EXTENSION_LANGUAGE: Readonly<Record<string, string>> = Object.freeze({
  * generator — there is no signature to emit for a markdown file — so these skip benignly and never
  * push the run to a non-zero exit.
  */
-const PROSE_EXTENSIONS: ReadonlySet<string> = new Set([
+const PROSE_EXTENSIONS                      = new Set([
   '.md', '.markdown', '.txt', '.rst',
   '.yaml', '.yml', '.json', '.jsonc', '.toml', '.ini', '.cfg', '.conf', '.env', '.lock',
   '.html', '.css', '.scss', '.svg', '.png', '.jpg', '.gif', '.csv',
@@ -53,7 +53,7 @@ const PROSE_EXTENSIONS: ReadonlySet<string> = new Set([
  * plan that touches one produces "no emitter for Java", not silence — the gap is real and belongs
  * in the manifest, not in a reader's assumptions.
  */
-const UNEMITTED_SOURCE_EXTENSIONS: Readonly<Record<string, { name: string; inProseGrammar: boolean }>> = Object.freeze({
+const UNEMITTED_SOURCE_EXTENSIONS                                                                      = Object.freeze({
   '.java': { name: 'Java', inProseGrammar: true },
   '.kt': { name: 'Kotlin', inProseGrammar: true },
   '.kts': { name: 'Kotlin', inProseGrammar: true },
@@ -73,7 +73,7 @@ const UNEMITTED_SOURCE_EXTENSIONS: Readonly<Record<string, { name: string; inPro
 
 /** Splits an identifier-ish path segment into lowercase words, so every language can re-case it
  * to its own convention from one parse. */
-function words(name: string): string[] {
+function words(name        )           {
   return name
     .replace(/\.[^.]+$/, '')
     .split(/[^A-Za-z0-9]+/)
@@ -82,9 +82,9 @@ function words(name: string): string[] {
     .map((part) => part.toLowerCase());
 }
 
-const camel = (parts: string[]): string => parts.map((w, i) => (i === 0 ? w : w[0].toUpperCase() + w.slice(1))).join('') || 'scaffold';
-const pascal = (parts: string[]): string => parts.map((w) => w[0].toUpperCase() + w.slice(1)).join('') || 'Scaffold';
-const snake = (parts: string[]): string => parts.join('_') || 'scaffold';
+const camel = (parts          )         => parts.map((w, i) => (i === 0 ? w : w[0].toUpperCase() + w.slice(1))).join('') || 'scaffold';
+const pascal = (parts          )         => parts.map((w) => w[0].toUpperCase() + w.slice(1)).join('') || 'Scaffold';
+const snake = (parts          )         => parts.join('_') || 'scaffold';
 
 /**
  * One entry per language this module can emit. Each `module` and `test` body is a signature plus a
@@ -92,10 +92,10 @@ const snake = (parts: string[]): string => parts.join('_') || 'scaffold';
  * `references/scaffold.md` — the same table the external-dependency case uses, so the two halves of
  * that document agree on what an unimplemented body looks like.
  */
-const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
+const EMITTERS                                = Object.freeze({
   javascript: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message }     ) => [
       '/**',
       ' * Placeholder signature — replace with the real surface before implementing.',
       ' * @returns {never}',
@@ -106,11 +106,11 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
       '',
       `module.exports = { ${symbol} };`,
     ].join('\n'),
-    testName: (id: string) => `${id}.test.js`,
-    test: ({ id, cases, message }: any) => [
+    testName: (id        ) => `${id}.test.js`,
+    test: ({ id, cases, message }     ) => [
       "const { test } = require('node:test');",
       '',
-      ...cases.map(({ statement }: any) => [
+      ...cases.map(({ statement }     ) => [
         `test(${JSON.stringify(`${id} — ${statement}`)}, () => {`,
         `  throw new Error(${JSON.stringify(message)});`,
         '});',
@@ -120,18 +120,18 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   typescript: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message }     ) => [
       '/** Placeholder signature — replace with the real surface before implementing. */',
       `export function ${symbol}(): never {`,
       `  throw new Error(${JSON.stringify(message)});`,
       '}',
     ].join('\n'),
-    testName: (id: string) => `${id}.test.ts`,
-    test: ({ id, cases, message }: any) => [
+    testName: (id        ) => `${id}.test.ts`,
+    test: ({ id, cases, message }     ) => [
       "import { test } from 'node:test';",
       '',
-      ...cases.map(({ statement }: any) => [
+      ...cases.map(({ statement }     ) => [
         `test(${JSON.stringify(`${id} — ${statement}`)}, (): void => {`,
         `  throw new Error(${JSON.stringify(message)});`,
         '});',
@@ -141,14 +141,14 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   python: {
-    line: (t: string) => (t ? `# ${t}` : '#'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `# ${t}` : '#'),
+    module: ({ symbol, message }     ) => [
       `def ${symbol}() -> None:`,
       '    """Placeholder signature — replace with the real surface before implementing."""',
       `    raise NotImplementedError(${JSON.stringify(message)})`,
     ].join('\n'),
-    testName: (id: string) => `test_${id.toLowerCase().replace(/-/g, '_')}.py`,
-    test: ({ cases, message }: any) => cases.map(({ statement }: any, i: number) => [
+    testName: (id        ) => `test_${id.toLowerCase().replace(/-/g, '_')}.py`,
+    test: ({ cases, message }     ) => cases.map(({ statement }     , i        ) => [
       `def test_case_${i + 1}() -> None:`,
       `    """${statement.replace(/"/g, "'")}"""`,
       `    raise NotImplementedError(${JSON.stringify(message)})`,
@@ -157,8 +157,8 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   go: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message, pkg }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message, pkg }     ) => [
       `package ${pkg}`,
       '',
       'import "errors"',
@@ -168,13 +168,13 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
       `\treturn errors.New(${JSON.stringify(message)})`,
       '}',
     ].join('\n'),
-    testName: (id: string) => `${id.toLowerCase().replace(/-/g, '_')}_test.go`,
-    test: ({ id, cases, message, pkg }: any) => [
+    testName: (id        ) => `${id.toLowerCase().replace(/-/g, '_')}_test.go`,
+    test: ({ id, cases, message, pkg }     ) => [
       `package ${pkg}`,
       '',
       'import "testing"',
       '',
-      ...cases.map(({ statement }: any, i: number) => [
+      ...cases.map(({ statement }     , i        ) => [
         `// ${statement}`,
         `func Test${pascal(words(id))}Case${i + 1}(t *testing.T) {`,
         `\tt.Fatal(${JSON.stringify(message)})`,
@@ -185,15 +185,15 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
   },
 
   rust: {
-    line: (t: string) => (t ? `// ${t}` : '//'),
-    module: ({ symbol, message }: any) => [
+    line: (t        ) => (t ? `// ${t}` : '//'),
+    module: ({ symbol, message }     ) => [
       '/// Placeholder signature — replace with the real surface before implementing.',
       `pub fn ${symbol}() {`,
       `    unimplemented!(${JSON.stringify(message)});`,
       '}',
     ].join('\n'),
-    testName: (id: string) => `${id.toLowerCase().replace(/-/g, '_')}.rs`,
-    test: ({ id, cases, message }: any) => cases.map(({ statement }: any, i: number) => [
+    testName: (id        ) => `${id.toLowerCase().replace(/-/g, '_')}.rs`,
+    test: ({ id, cases, message }     ) => cases.map(({ statement }     , i        ) => [
       `// ${statement}`,
       '#[test]',
       `fn ${snake(words(id))}_case_${i + 1}() {`,
@@ -212,12 +212,12 @@ const EMITTERS: Readonly<Record<string, any>> = Object.freeze({
  * TypeScript. The one extra bit is read from its own output (a `typecheck` role exists only when a
  * tsc script or a `tsconfig.json` was found), so no second detector is introduced.
  */
-function repoLanguage(repoRoot: string, fsImpl: any): any {
+function repoLanguage(repoRoot        , fsImpl     )      {
   const detected = detectCommands({ projectRoot: repoRoot, fsImpl });
   if (!detected.manifestFound) {
     return { id: null, signal: 'none', why: 'no build manifest found by command-detect.ts' };
   }
-  const has = (name: string) => detected.manifests.includes(name);
+  const has = (name        ) => detected.manifests.includes(name);
   if (has('package.json')) {
     const typescript = Boolean(detected.commands.typecheck);
     return { id: typescript ? 'typescript' : 'javascript', signal: 'package.json', why: null };

package/src/runtime/source-version.js

@@ -0,0 +1,289 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { execFileSync } = require('node:child_process');
+
+                     
+                           
+                            
+                        
+                             
+ 
+
+                                                                 
+
+                         
+                           
+                          
+                          
+ 
+
+const treeStateMemo = new Map                   ();
+
+function clearTreeStateCache()       {
+  treeStateMemo.clear();
+}
+
+/**
+ * Finds the top of the git work tree and root's relative prefix below it using filesystem reads only.
+ */
+function findWorkTreeTop(root        )                                                {
+  let current = path.resolve(root);
+  while (true) {
+    try {
+      if (fs.existsSync(path.join(current, '.git'))) {
+        const rel = path.relative(current, path.resolve(root));
+        const prefix = rel && rel !== '.' ? (rel.split(path.sep).join('/') + '/') : '';
+        return { top: current, prefix };
+      }
+    } catch {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return { top: null, prefix: null };
+}
+
+function defaultGitRunner(args          , cwd        )                {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf8',
+      timeout: 2000,
+      maxBuffer: 256 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Measures the repository's HEAD commit, dirty paths and tree fingerprint with one git status call.
+ */
+function measureTreeState(root        , runner            )            {
+  const absRoot = path.resolve(root);
+  if (!runner && treeStateMemo.has(absRoot)) {
+    return treeStateMemo.get(absRoot) ;
+  }
+
+  const { top: workTreeTop, prefix } = findWorkTreeTop(absRoot);
+  if (!workTreeTop) {
+    const unmeasured            = {
+      gitCommit: null,
+      dirty: null,
+      prefix: null,
+      fingerprint: null,
+    };
+    if (!runner) treeStateMemo.set(absRoot, unmeasured);
+    return unmeasured;
+  }
+
+  const args = ['-C', absRoot, 'status', '--porcelain=v2', '--branch', '-z', '--untracked-files=all', '--ignored=matching'];
+  const raw = runner ? runner(args, absRoot) : defaultGitRunner(args, absRoot);
+
+  if (raw === null || raw === undefined) {
+    const commit = runner
+      ? runner(['-C', absRoot, 'rev-parse', 'HEAD'], absRoot)
+      : defaultGitRunner(['-C', absRoot, 'rev-parse', 'HEAD'], absRoot);
+    const failed            = {
+      gitCommit: commit?.trim() || null,
+      dirty: null,
+      prefix,
+      fingerprint: null,
+    };
+    if (!runner) treeStateMemo.set(absRoot, failed);
+    return failed;
+  }
+
+  const tokens = raw.split('\0');
+  let gitCommit                = null;
+  const dirty = new Set        ();
+  const entryRecords           = [];
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+
+    if (token.startsWith('# branch.oid ')) {
+      const oid = token.slice('# branch.oid '.length).trim();
+      if (oid && oid !== '(initial)') {
+        gitCommit = oid;
+      }
+      continue;
+    }
+    if (token.startsWith('# ')) {
+      continue;
+    }
+
+    if (token.startsWith('! ')) {
+      const ignoredPath = token.slice(2);
+      if (prefix && (ignoredPath === prefix.slice(0, -1) || ignoredPath === `${prefix.slice(0, -1)}/`)) {
+        const ignored            = { gitCommit, dirty: null, prefix, fingerprint: null };
+        if (!runner) treeStateMemo.set(absRoot, ignored);
+        return ignored;
+      }
+      continue;
+    }
+
+    let dirtyPath                = null;
+    let entryText = token;
+
+    if (token.startsWith('1 ')) {
+      const parts = token.split(' ');
+      dirtyPath = parts.slice(8).join(' ');
+      dirty.add(dirtyPath);
+    } else if (token.startsWith('2 ')) {
+      const parts = token.split(' ');
+      dirtyPath = parts.slice(9).join(' ');
+      dirty.add(dirtyPath);
+      if (i + 1 < tokens.length && tokens[i + 1]) {
+        const origPath = tokens[i + 1];
+        dirty.add(origPath);
+        entryText = `${token}\0${origPath}`;
+        i++;
+      }
+    } else if (token.startsWith('u ')) {
+      const parts = token.split(' ');
+      dirtyPath = parts.slice(10).join(' ');
+      dirty.add(dirtyPath);
+    } else if (token.startsWith('? ')) {
+      dirtyPath = token.slice(2);
+      dirty.add(dirtyPath);
+    }
+
+    if (dirtyPath !== null) {
+      const statePath = `${prefix}.doflow/state/`;
+      const normalizedDirtyPath = dirtyPath.split(path.sep).join('/');
+      const shouldFingerprint = !normalizedDirtyPath.startsWith(statePath);
+      if (shouldFingerprint && /^(?:1|2|u) \S+ S\.M /.test(token)) {
+        const nestedRoot = path.resolve(workTreeTop, dirtyPath);
+        const nested = measureNestedRepository(nestedRoot);
+        if (nested === null) {
+          const unknown            = { gitCommit, dirty: null, prefix, fingerprint: null };
+          if (!runner) treeStateMemo.set(absRoot, unknown);
+          return unknown;
+        }
+        entryRecords.push(`${entryText}:nested:${nested}`);
+        continue;
+      }
+      if (shouldFingerprint && token.startsWith('? ')) {
+        const nestedRoot = path.resolve(workTreeTop, dirtyPath.replace(/\/$/, ''));
+        if (fs.existsSync(path.join(nestedRoot, '.git'))) {
+          const nested = measureNestedRepository(nestedRoot);
+          if (nested === null) {
+            const unknown            = { gitCommit, dirty: null, prefix, fingerprint: null };
+            if (!runner) treeStateMemo.set(absRoot, unknown);
+            return unknown;
+          }
+          entryRecords.push(`${entryText}:nested:${nested}`);
+          continue;
+        }
+      }
+      if (!shouldFingerprint) continue;
+      let statTerm = 'absent';
+      try {
+        const absPath = path.resolve(workTreeTop, dirtyPath);
+        const st = fs.statSync(absPath);
+        statTerm = `${st.size}:${st.mtimeMs}`;
+      } catch {
+        statTerm = 'absent';
+      }
+      entryRecords.push(`${entryText}:${statTerm}`);
+    }
+  }
+
+  if (!gitCommit) {
+    const uncommitted            = {
+      gitCommit: null,
+      dirty: null,
+      prefix,
+      fingerprint: null,
+    };
+    if (!runner) treeStateMemo.set(absRoot, uncommitted);
+    return uncommitted;
+  }
+
+  const hash = crypto.createHash('sha256');
+  hash.update(gitCommit);
+  hash.update('\0');
+  hash.update(entryRecords.sort().join('\0'));
+  const fingerprint = `sha256:${hash.digest('hex')}`;
+
+  const state            = {
+    gitCommit,
+    dirty,
+    prefix,
+    fingerprint,
+  };
+  if (!runner) treeStateMemo.set(absRoot, state);
+  return state;
+}
+
+function measureNestedRepository(root        )                {
+  try {
+    const gitEntry = path.join(root, '.git');
+    const gitStat = fs.statSync(gitEntry);
+    const gitDir = gitStat.isFile()
+      ? path.resolve(root, fs.readFileSync(gitEntry, 'utf8').trim().replace(/^gitdir:\s*/, ''))
+      : gitEntry;
+    const head = fs.readFileSync(path.join(gitDir, 'HEAD'), 'utf8').trim();
+    const headRef = head.startsWith('ref: ')
+      ? fs.readFileSync(path.join(gitDir, head.slice('ref: '.length)), 'utf8').trim()
+      : head;
+    const index = fs.statSync(path.join(gitDir, 'index'));
+    return `${head}:${headRef}:${index.mtimeMs}:${index.size}`;
+  } catch {
+    return null;
+  }
+}
+
+function fileHash(root        , locator     )                {
+  if (!locator?.file) return null;
+  try {
+    const absolute = path.resolve(root, locator.file);
+    if (!fs.statSync(absolute).isFile()) return null;
+    return `sha256:${crypto.createHash('sha256').update(fs.readFileSync(absolute)).digest('hex')}`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Derives source version { gitCommit, fileHash, isDirty } for a given locator and tree state.
+ */
+function sourceVersionFor(root        , locator     , state           )                {
+  const hash = fileHash(root, locator);
+  if (!locator?.file || !state || !state.dirty) {
+    return {
+      gitCommit: state?.gitCommit ?? null,
+      fileHash: hash,
+      isDirty: null,
+    };
+  }
+
+  const prefix = state.prefix || '';
+  if (path.isAbsolute(locator.file)) {
+    return { gitCommit: state.gitCommit ?? null, fileHash: hash, isDirty: null };
+  }
+  const candidate = path.posix.normalize(`${prefix}${locator.file.split(path.sep).join('/')}`).replace(/^\.\//, '');
+  const isDirty = state.dirty.has(candidate);
+
+  return {
+    gitCommit: state.gitCommit ?? null,
+    fileHash: hash,
+    isDirty,
+  };
+}
+
+module.exports = {
+  measureTreeState,
+  sourceVersionFor,
+  clearTreeStateCache,
+};

package/src/runtime/storage/{cli.ts → cli.js}

@@ -4,13 +4,13 @@
 
 const path = require('node:path');
 const fs = require('node:fs');
-const { loadStorageRegistry } = require('./registry.ts');
-const { resolveRoots, readPruneSetting } = require('./roots.ts');
-const { runPass } = require('./engine.ts');
-const { upkeepAfterVerb } = require('./upkeep.ts');
-const { REPO_ROOT } = require('../../helper/repo-root.ts');
+const { loadStorageRegistry } = require('./registry.js');
+const { resolveRoots, readPruneSetting } = require('./roots.js');
+const { runPass } = require('./engine.js');
+const { upkeepAfterVerb } = require('./upkeep.js');
+const { REPO_ROOT } = require('../../helper/repo-root.js');
 
-function handleStorageCommand({ action = 'report', json = false, global = false, projectRoot = '.', env = process.env, fsImpl = fs }: any = {}) {
+function handleStorageCommand({ action = 'report', json = false, global = false, projectRoot = '.', env = process.env, fsImpl = fs }      = {}) {
   if (!['report', 'prune', 'upkeep'].includes(action)) {
     console.error(`doflow storage: unknown action '${action}' (expected report, prune, or upkeep)`);
     process.exitCode = 2;
@@ -23,7 +23,7 @@ function handleStorageCommand({ action = 'report', json = false, global = false,
   }
   let registry;
   try { registry = loadStorageRegistry({ repoRoot: REPO_ROOT, fsImpl }); }
-  catch (error: any) {
+  catch (error     ) {
     console.error(`doflow storage: storage registry unavailable${error.message ? `: ${error.message}` : ''}`);
     process.exitCode = 2;
     return;
@@ -35,7 +35,7 @@ function handleStorageCommand({ action = 'report', json = false, global = false,
     readPruneSetting({ registry, roots, rootId, fsImpl })]));
   const mode = action === 'prune' ? 'prune' : 'report';
   const result = runPass({ registry, roots, mode, setting, now: Date.now(), env, fsImpl });
-  const removed = result.stores.reduce((sum: any, row: any) => sum + row.removed, 0);
+  const removed = result.stores.reduce((sum     , row     ) => sum + row.removed, 0);
   const entries = `entr${removed === 1 ? 'y' : 'ies'}`;
   if (action === 'prune' && Object.values(setting).every(value => value.setting === 'off')) {
     const decision = projectSetting.decidedBy || userSetting.decidedBy || path.join(roots['config-home'], registry.settings.optOutFile);
@@ -54,7 +54,7 @@ function handleStorageCommand({ action = 'report', json = false, global = false,
   }
   console.log(`Settings: project ${projectSetting.setting}${projectSetting.decidedBy ? ` (${projectSetting.decidedBy})` : ' (default)'}; user ${userSetting.setting}${userSetting.decidedBy ? ` (${userSetting.decidedBy})` : ' (default)'}`);
   for (const row of result.stores) {
-    const names = row.selected.slice(0, 20).map((entry: any) => entry.name);
+    const names = row.selected.slice(0, 20).map((entry     ) => entry.name);
     const more = row.selected.length > 20 ? `\n    ... and ${row.selected.length - 20} more` : '';
     console.log(`${row.id}\n  Location: ${row.location || '(not configured)'}\n  Entries: ${row.entries}; size: ${row.bytes} bytes\n  Bound: ${row.bound}\n  Would remove: ${row.selected.length}${names.length ? `\n    ${names.join('\n    ')}` : ''}${more}`);
   }